Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

c6809.c @ 2

Last change on this file since 2 was 1, checked in by svn, 6 years ago
Import initial
File size: 146.3 KB

Rev	Line
[1]	1	/*
	2	* C6809 - Compilateur macro-assembler pour Thomson (MacroAssembler-like)
	3	*
	4	* Programme principal
	5	*
	6	* Copyright (C) mars 2010 François Mouret
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*/
	22
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <ctype.h>
	26	#include <string.h>
	27
	28	#ifndef TRUE
	29	# define TRUE 1
	30	#endif
	31
	32	#ifndef FALSE
	33	# define FALSE 0
	34	#endif
	35
	36	#ifndef NULL
	37	# define NULL 0
	38	#endif
	39
	40
	41	/***********************************************************************
	42	*
	43	* Variables globales
	44	*
	45	***********************************************************************/
	46
	47	#define CHAR127 '\|' /* Caractère de remplacement pour CHR$(127) */
	48	#define ARGV_MAX_SIZE 300
	49	#define LINE_MAX_SIZE 75 /* Taille maximum de la ligne à afficher */
	50	#define ARG_MAX_SIZE 40 /* Taille maximum d'un argument */
	51	#define ASM_MAX_SIZE 29000 /* Taille maximum en octets pour un fichier ASM */
	52
	53	/* Correspondance caractères 'Occidental ISO-8859' */
	54	unsigned char acc_table[] = {
	55	0xE7, /* ç */
	56	0xE1, /* á */
	57	0xE2, /* â */
	58	0xE4, /* ä */
	59	0xE0, /* à */
	60	0xE9, /* é */
	61	0xEA, /* ê */
	62	0xEB, /* ë */
	63	0xE8, /* è */
	64	0xEE, /* î */
	65	0xEF, /* ï */
	66	0xF4, /* ô */
	67	0xF6, /* ö */
	68	0xFB, /* û */
	69	0xFC, /* ü */
	70	0xF9 /* ù */
	71	} ;
	72
	73	FILE fp_lst = NULL ; / Pour listing d'assemblage */
	74	FILE fp_asm = NULL ; / Pour sauvegarde au format ASM */
	75	char linebuffer[LINE_MAX_SIZE+2] ; /* Buffer de ligne */
	76	char line ; / Pointeur de ligne */
	77	char filebuffer ; / Buffer de source */
	78	char source ; / Pointeur de source */
	79	char arg[ARG_MAX_SIZE+2] ; /* Buffer d'argument */
	80	char labelname[ARG_MAX_SIZE+2] ; /* Buffer du nom d'étiquette */
	81
	82
	83	/* -------------------------------------------------------------------
	84	* Pour scan du source
	85	*/
	86	enum{
	87	SOFT_ASSEMBLER,
	88	SOFT_MACROASSEMBLER,
	89	SOFT_UPDATE
	90	} ;
	91	enum{
	92	TO_COMPUTER,
	93	TO7_COMPUTER,
	94	MO_COMPUTER
	95	} ;
	96	enum{
	97	OPT_NO, /* Pas de code objet */
	98	OPT_OP, /* Optimisation */
	99	OPT_SS, /* Lignes séparées (sans effet) */
	100	OPT_WE, /* Attente à l'erreur (sans effet) */
	101	OPT_WL, /* Affiche les lignes à l'assemblage */
	102	OPT_WS, /* Affiche les symboles à l'assemblage */
	103	OPT_SIZEOF
	104	} ;
	105	struct {
	106	int opt[OPT_SIZEOF] ; /* Table des options initiales (passage d'argument) */
	107	int computer ; /* Type de machine sélectionnée */
	108	int soft ; /* Type d'assembleur sélectionné */
	109	int symb_order ; /* Ordre d'affichage des symboles */
	110	int err_order ; /* Ordre d'affichage des erreurs */
	111	int limit ; /* Taille limite d'une ligne */
	112	} scan ;
	113
	114
	115	/*-------------------------------------------------------------------
	116	* Pour assemblage du source
	117	*/
	118	enum{
	119	SCANPASS, /* Pass de scan */
	120	MACROPASS, /* Pass de macro */
	121	PASS1, /* Pass 1 d'assemblage */
	122	PASS2 /* Pass 2 d'assemblage */
	123	} ;
	124	enum {
	125	UNLOCKED,
	126	IF_LOCK,
	127	MACRO_LOCK,
	128	COMMENT_LOCK = 4
	129	} ;
	130
	131	struct {
	132	char source ; / Pointeur courant sur le source */
	133	int line ; /* Numéro de ligne courante */
	134	int pass ; /* Numéro du pass d'assemblage */
	135	int locked ; /* Bloque l'enregistrement des codes machine */
	136	int exit ; /* Demande l'arrêt de l'assemblage si directive 'END' */
	137	int size ; /* Taille de l'assemblage */
	138	unsigned char code[5] ; /* Buffer d'assemblage */
	139	unsigned char dp ; /* Valeur du DP */
	140	unsigned short pc ; /* Valeur du PC */
	141	unsigned short exec ; /* Valeur de l'adresse d'exécution */
	142	int regcode ; /* Code du registre éventuel (délivré par ScanLine()) */
	143	int opt[OPT_SIZEOF] ; /* Table des options courantes */
	144	} run ;
	145
	146
	147	/*-------------------------------------------------------------------
	148	* Pour évaluation d'opérande
	149	*/
	150	struct {
	151	int priority ; /* Priorité de l'opérateur */
	152	char sign ; /* Signe de l'opérateur */
	153	signed short operand ; /* Valeur opérande */
	154	int type ; /* SET_VALUE/EQU_VALUE/LABEL_VALUE/MACRO_VALUE
	155	* renvoyé par DoSymbol() (et donc Eval())*/
	156	int pass ; /* Pass de la dernière évaluation */
	157	} eval ;
	158
	159
	160	/*-------------------------------------------------------------------
	161	* Pour assemblage conditionnel
	162	*/
	163	enum {
	164	IF_TRUE,
	165	IF_TRUE_ELSE,
	166	IF_FALSE,
	167	IF_FALSE_ELSE,
	168	IF_STOP
	169	} ;
	170	struct {
	171	int count ; /* Compteur de degrés d'assemblage conditionnel */
	172	int buf[17] ; /* Buffer des degrés d'assemblage conditionnel */
	173	} ifc ;
	174
	175
	176	/*-------------------------------------------------------------------
	177	* Pour macro
	178	*/
	179	struct {
	180	int count ; /* Identificateur de macro */
	181	int level ; /* Degré d'appel de macro */
	182	} macro ;
	183
	184
	185	/*-------------------------------------------------------------------
	186	* Pour marquage 'info'
	187	*/
	188	struct {
	189	struct {
	190	int count ; /* Nombre de cycles de base (-1 si pas) */
	191	int plus ; /* Nombre de cycles ajoutés (-1 si pas) */
	192	int total ; /* Total du nombre de cycles */
	193	} cycle ;
	194	int size ; /* Taille du code assemblé parcouru */
	195	} info ;
	196
	197
	198	/*-------------------------------------------------------------------
	199	* Pour marquage 'check'
	200	*/
	201	int check[4][2] ;
	202
	203
	204	/*-------------------------------------------------------------------
	205	* Pour INCLUD
	206	*/
	207	struct INCLIST {
	208	struct INCLIST prev ; / Pointeur sur l'INCLUD précédent */
	209	int drive ; /* Numéro de lecteur */
	210	char name[13] ; /* Nom du fichier : xxxxxxxx.xxx */
	211	int line ; /* Numéro de ligne de l'INCLUD */
	212	int count ; /* Compteur d'INCLUD */
	213	char start ; / Pointeur sur début du code d'INCLUD */
	214	char end ; / Pointeur sur fin du code d'INCLUD */
	215	} ;
	216
	217	struct INCLIST *first_includ ;
	218
	219	/*-------------------------------------------------------------------
	220	* Liste des codes d'erreur
	221	*/
	222	enum {
	223	NO_ERROR, /* Pas d'erreur */
	224	ERR_ERROR, /* Erreur */
	225	/* Erreurs affichées sans condition */
	226	ERR_DUPLICATE_MAIN,
	227	ERR_DUPLICATE_NAME,
	228	ERR_FILE_NOT_FOUND,
	229	ERR_ILLEGAL_CHAR,
	230	ERR_IO_ERROR,
	231	ERR_MISSING_MAIN,
	232	ERR_WRONG_MARK,
	233	ERR_EMBEDDED_MACRO,
	234	____BREAK_ERROR,
	235	/* Erreurs affichées seulement au pass 2 de l'assemblage avec
	236	* affichage de la ligne du source */
	237	ERR_BAD_ELSE,
	238	ERR_BAD_FILE_FORMAT,
	239	ERR_BAD_FILE_NAME,
	240	ERR_BAD_LABEL,
	241	ERR_BAD_MACRO_NAME,
	242	ERR_BAD_OPERAND,
	243	ERR_BAD_OPCODE,
	244	ERR_BAD_PARAM,
	245	ERR_DIVISION_BY_ZERO,
	246	ERR_ENDM_WITHOUT_MACRO,
	247	ERR_EXPRESSION_ERROR,
	248	ERR_IF_OUT_OF_RANGE,
	249	ERR_ILLEGAL_INCLUDE,
	250	ERR_ILLEGAL_LABEL,
	251	ERR_ILLEGAL_OPERAND,
	252	ERR_INCLUDE_OUT_OF_RANGE,
	253	ERR_LABEL_NAME_TOO_LONG,
	254	ERR_MACRO_ERROR,
	255	ERR_MACRO_INTO_IF_RANGE,
	256	ERR_MACRO_OUT_OF_RANGE,
	257	ERR_MISSING_ENDC,
	258	ERR_MISSING_IF,
	259	ERR_MISSING_INFORMATION,
	260	ERR_MISSING_LABEL,
	261	ERR_MISSING_OPERAND,
	262	ERR_MULTIPLY_DEFINED_SYMBOL,
	263	ERR_OPERAND_IS_MACRO,
	264	ERR_SYMBOL_ERROR,
	265	ERR_UNDEFINED_MACRO,
	266	/* Erreurs affichées seulement au pass 2 de l'assemblage mais
	267	* sans afficher la ligne du source
	268	* Pour certaines, l'erreur n'est pas affichée en 'return'
	269	* pour que le pass 1 ne récupère pas une erreur dans le cas où
	270	* l'étiquette se trouve après le branchement, alors que le pass
	271	* 2 n'en récupèrera aucune si l'étiquette a été répertoriée au
	272	* pass 1 */
	273	____NO_LINE_ERROR,
	274	ERR_LINE_TOO_LONG,
	275	ERR_0_BIT,
	276	ERR_5_BITS,
	277	ERR_8_BITS,
	278	ERR_BINARY_NOT_LINEAR,
	279	ERR_BRANCH_OUT_OF_RANGE,
	280	ERR_CHECK_ERROR,
	281	ERR_DP_ERROR,
	282	ERR_OPERAND_OUT_OF_RANGE,
	283	ERR_FORCE_TO_DP,
	284	ERR_LONE_SYMBOL,
	285	ERR_MISSING_END_STATEMENT,
	286	ERR_MISSING_ENDM,
	287	ERR_MISSING_SLASH,
	288	ERR_REGISTER_ERROR
	289	} ;
	290
	291
	292	/*
	293	* Capitalise un caractère
	294	*/
	295	unsigned char upper_case(char c)
	296	{
	297	if((c >= 'a') && (c <= 'z'))
	298	c &= 0xDF ;
	299	return c ;
	300	}
	301
	302	/*
	303	* Capitalise une chaîne de caractères
	304	*/
	305	void upper_string(char *p)
	306	{
	307	while(*p != '\0')
	308	{
	309	if((p >= 'a') && (p <= 'z'))
	310	*p &= 0xDF ;
	311	p++ ;
	312	}
	313	}
	314
	315
	316	/***********************************************************************
	317	*
	318	* Analyse et copie d'une ligne du source pour scan/assemblage
	319	*
	320	***********************************************************************/
	321
	322	#define COLON_300 300
	323	#define COLON_40 40
	324
	325	/* Stocke la ligne suivante
	326	* - Les tabulations sont transformées en série d'espace
	327	* - La validité des caractères accentués est vérifiée
	328	* - La taille de la ligne est vérifiée
	329	*/
	330	int GetLine(void)
	331	{
	332	int i ;
	333	int space ;
	334	int error = NO_ERROR ;
	335	int size = 0 ;
	336
	337	run.source = source ;
	338	line = linebuffer ;
	339	*line = '\0' ;
	340
	341	while ((size < LINE_MAX_SIZE-1)
	342	&& (*source != 0x00)
	343	&& (*source != 0x0A)
	344	&& (*source != 0x0D))
	345	{
	346	/* Caractère de tabulation */
	347	if(*source == 0x09)
	348	{
	349	space = 7 - (size % 7) ;
	350	for(i=0;i<space;i++)
	351	*(line++) = 0x20 ;
	352	size += space ;
	353	}
	354	else
	355	/* Caractères accentués */
	356	if ((unsigned char)*source > 0x7F)
	357	{
	358	i = 0 ;
	359	while((i<16) && ((unsigned char)*source != acc_table[i])) i++ ;
	360	if (i == 16)
	361	error = ERR_ILLEGAL_CHAR ;
	362	(line++) = source ;
	363	size++ ;
	364	}
	365	else
	366	/* Caractères de commande */
	367	if ((unsigned char)*source < 0x20)
	368	error = ERR_ILLEGAL_CHAR ;
	369	else {
	370	(line++) = source ;
	371	size++ ; }
	372	source++ ;
	373	}
	374
	375	/* Clôt la ligne */
	376	*(line++) = '\0' ;
	377
	378	/* Notifie le dépassement */
	379	if(size > scan.limit)
	380	error = ERR_LINE_TOO_LONG ;
	381
	382	/* Va jusqu'au bout de la ligne */
	383	while ((*source != 0x00)
	384	&& (*source != 0x0A)
	385	&& (*source != 0x0D)) {
	386	size++ ;
	387	source++ ; }
	388	switch(*source)
	389	{
	390	case 0x0A : if (*(source+1) == 0x0D) source++ ; break ;
	391	case 0x0D : if (*(source+1) == 0x0A) source++ ; break ;
	392	}
	393	source++ ;
	394
	395	/* Elimine les caractères inutiles de fin de ligne */
	396	while (((unsigned char)*(--line) <= 0x20)
	397	&& (size > 0)) {
	398	*(line) = 0x00 ;
	399	size-- ; }
	400
	401	/* Initialise les paramètres de lignes */
	402	run.line++ ;
	403	line = linebuffer ;
	404
	405	return error ;
	406	}
	407
	408
	409	/***********************************************************************
	410	*
	411	* Traitement des erreurs
	412	*
	413	***********************************************************************/
	414
	415	/* La liste err_table est dans l'ordre pour l'affichage par code d'erreur */
	416	#define ETSTRINGSIZE 24
	417	const struct {
	418	char string[ETSTRINGSIZE] ; /* Message de l'erreur */
	419	int code ; /* Code de l'erreur */
	420	} err_table[] = {
	421	/* Erreurs de scan prioritaires */
	422	{ "Missing (main)" , ERR_MISSING_MAIN },
	423	{ "Duplicate (main)" , ERR_DUPLICATE_MAIN },
	424	{ "Duplicate Name" , ERR_DUPLICATE_NAME },
	425	{ "Line Too Long" , ERR_LINE_TOO_LONG },
	426	{ "Illegal Char" , ERR_ILLEGAL_CHAR },
	427	{ "Wrong Mark" , ERR_WRONG_MARK },
	428	/* Erreurs d'assemblage prioritaires (PASS1) */
	429	{ "File Not Found" , ERR_FILE_NOT_FOUND },
	430	{ "I/O Error" , ERR_IO_ERROR },
	431	{ "Missing Endm" , ERR_MISSING_ENDM },
	432	{ "Bad File Format" , ERR_BAD_FILE_FORMAT },
	433	{ "Bad File Name" , ERR_BAD_FILE_NAME },
	434	{ "Include Out Of Range" , ERR_INCLUDE_OUT_OF_RANGE },
	435	/* Erreurs d'optimisation */
	436	{ "0 bit" , ERR_0_BIT },
	437	{ "5 bits" , ERR_5_BITS },
	438	{ "8 bits" , ERR_8_BITS },
	439	{ "Lone Symbol" , ERR_LONE_SYMBOL },
	440	{ "Force To DP" , ERR_FORCE_TO_DP },
	441	/* Erreurs courantes */
	442	{ "Expression Error" , ERR_EXPRESSION_ERROR },
	443	{ "Branch Out Of Range" , ERR_BRANCH_OUT_OF_RANGE },
	444	{ "Bad Operand" , ERR_BAD_OPERAND },
	445	{ "Bad Label" , ERR_BAD_LABEL },
	446	{ "Bad Opcode" , ERR_BAD_OPCODE },
	447	{ "Missing Operand" , ERR_MISSING_OPERAND },
	448	{ "Multiply Defined Symbol" , ERR_MULTIPLY_DEFINED_SYMBOL },
	449	{ "Operand Out Of Range" , ERR_OPERAND_OUT_OF_RANGE },
	450	{ "Symbol Error" , ERR_SYMBOL_ERROR },
	451	{ "DP Error" , ERR_DP_ERROR },
	452	{ "Division By Zero" , ERR_DIVISION_BY_ZERO },
	453	/* Erreur de condition */
	454	{ "If Out Of Range" , ERR_IF_OUT_OF_RANGE },
	455	{ "Missing If" , ERR_MISSING_IF },
	456	{ "Missing Endc" , ERR_MISSING_ENDC },
	457	{ "Bad Else" , ERR_BAD_ELSE },
	458	/* Erreur de macro */
	459	{ "Illegal Include" , ERR_ILLEGAL_INCLUDE },
	460	{ "Bad Macro Name" , ERR_BAD_MACRO_NAME },
	461	{ "Macro Error" , ERR_MACRO_ERROR },
	462	{ "Macro Into If Range" , ERR_MACRO_INTO_IF_RANGE },
	463	{ "Macro Out Of Range" , ERR_MACRO_OUT_OF_RANGE },
	464	/* Erreur peu courantes */
	465	{ "Bad Param" , ERR_BAD_PARAM },
	466	{ "Check Error" , ERR_CHECK_ERROR },
	467	{ "Embedded Macro" , ERR_EMBEDDED_MACRO },
	468	{ "Missing Information" , ERR_MISSING_INFORMATION },
	469	{ "Missing Label" , ERR_MISSING_LABEL },
	470	{ "Illegal Label" , ERR_ILLEGAL_LABEL },
	471	{ "Label Name Too Long" , ERR_LABEL_NAME_TOO_LONG },
	472	{ "Illegal Operand" , ERR_ILLEGAL_OPERAND },
	473	{ "Operand Is Macro" , ERR_OPERAND_IS_MACRO },
	474	{ "Register Error" , ERR_REGISTER_ERROR },
	475	{ "Binary Not Linear" , ERR_BINARY_NOT_LINEAR },
	476	{ "DP Error" , ERR_DP_ERROR },
	477	{ "Endm Without Macro" , ERR_ENDM_WITHOUT_MACRO },
	478	{ "Undefined Macro" , ERR_UNDEFINED_MACRO },
	479	{ "Missing Slash" , ERR_MISSING_SLASH },
	480	{ "Missing End Statement" , ERR_MISSING_END_STATEMENT }
	481	} ;
	482	#define ETSIZE (int)sizeof(err_table)/(int)sizeof(err_table[0])
	483
	484	struct ERRLIST {
	485	struct ERRLIST next ; / Pointeur sur section suivante */
	486	int error ; /* Numéro de l'erreur */
	487	int line ; /* Numéro de la ligne */
	488	char source ; / Ponteur sur la ligne du source */
	489	} ;
	490
	491	struct ERRLIST *first_error ;
	492
	493	/*
	494	* Initialise le chaînage des erreurs
	495	*
	496	* Le premier élément de la liste (pointé par first_error) ne contient
	497	* qu'un pointeur 'next', et le numéro de sa ligne est à 0
	498	* Ainsi, le pointeur first_error est invariable
	499	*/
	500	void InitErrorChain(void)
	501	{
	502	first_error = malloc(sizeof(struct ERRLIST)) ;
	503	first_error->line = 0 ;
	504	first_error->next = NULL ;
	505	}
	506
	507	/*
	508	* Libère la mémoire pour le chaînage des erreurs
	509	*/
	510	void FreeErrorChain(void)
	511	{
	512	struct ERRLIST *current_error ;
	513
	514	while ((current_error = first_error))
	515	{
	516	first_error = first_error->next ;
	517	free(current_error) ;
	518	}
	519	}
	520
	521	/*
	522	* Limite la taille de la ligne à afficher
	523	*/
	524	void MakeLimitedLine(char *formatstring)
	525	{
	526	int size = LINE_MAX_SIZE - (int)strlen(formatstring) ;
	527	if (size > 0)
	528	strncat(formatstring,linebuffer,LINE_MAX_SIZE - (int)strlen(formatstring)) ;
	529	formatstring[LINE_MAX_SIZE] = '>' ;
	530	formatstring[LINE_MAX_SIZE+1] = '>' ;
	531	formatstring[LINE_MAX_SIZE+2] = '\0' ;
	532	}
	533
	534	/*
	535	* Affiche une erreur pour la liste de fin d'assemblage
	536	*/
	537	void PrintErrorListLine(struct ERRLIST *rlist)
	538	{
	539	char formatstring[LINE_MAX_SIZE+3] ;
	540	char fmt[10] ;
	541
	542	sprintf(fmt,"%%%ds %% 7d ",ETSTRINGSIZE) ;
	543	sprintf(formatstring,fmt,
	544	err_table[rlist->error].string,
	545	rlist->line) ;
	546	source = rlist->source ;
	547	GetLine() ;
	548	MakeLimitedLine(formatstring) ;
	549	fprintf(fp_lst,"%s\n",formatstring) ;
	550	}
	551
	552	/*
	553	* Affiche/Enregistre les erreurs pour l'assemblage
	554	*/
	555	int PrintError(int code)
	556	{
	557	int i ;
	558	struct ERRLIST *current_error ;
	559	struct ERRLIST *found_error ;
	560	struct ERRLIST *new_error ;
	561	char formatstring[LINE_MAX_SIZE+3] ;
	562	char filestring[15] ;
	563
	564	if ((code != NO_ERROR)
	565	&& (code != ERR_ERROR))
	566	{
	567	/* Recherche la position de l'erreur */
	568	i = 0 ;
	569	while((i<ETSIZE) && (code != err_table[i].code)) i++ ;
	570	code = i ;
	571
	572	/* Filtrage d'affichage
	573	* L'erreur doit être affichée à tous les coups ou seulement au
	574	* pass 2
	575	*/
	576	if ((run.pass == SCANPASS)
	577	\|\| (err_table[code].code < ____BREAK_ERROR)
	578	\|\| ((err_table[code].code > ____BREAK_ERROR) && (run.pass == PASS2)))
	579	{
	580	/* Affiche/Enregistre l'erreur */
	581	filestring[0] = '\0' ;
	582	if ((first_includ != NULL)
	583	&& (first_includ->count != 0))
	584	sprintf(filestring,"%d:%s",
	585	first_includ->drive,
	586	first_includ->name) ;
	587	sprintf(formatstring,"(%d)%s %s",
	588	run.line,
	589	filestring,
	590	err_table[code].string) ;
	591	fprintf(fp_lst,"%s\n",formatstring) ;
	592	printf("%s\n",formatstring) ;
	593
	594	/* Affiche éventuellement la ligne du source */
	595	sprintf(formatstring, "% 7d ", run.line) ;
	596	MakeLimitedLine(formatstring) ;
	597	if (err_table[code].code < ____NO_LINE_ERROR)
	598	fprintf(fp_lst,"%s\n",formatstring) ;
	599	if (run.opt[OPT_WL] == FALSE)
	600	printf("%s\n",formatstring) ;
	601
	602	/* Collecte les erreurs pour fin d'assemblage
	603	Le programme en profite pour ranger les erreurs dans
	604	l'ordre croissant des numéros de lignes */
	605	current_error = first_error ;
	606	do {
	607	found_error = current_error ;
	608	current_error = current_error->next ;
	609	} while((current_error != NULL)
	610	&& (current_error->line <= run.line)) ;
	611	new_error = malloc(sizeof(struct ERRLIST)) ;
	612	found_error->next = new_error ;
	613	new_error->next = current_error ;
	614	new_error->error = code ;
	615	new_error->line = run.line ;
	616	new_error->source = run.source ;
	617	}
	618	code = ERR_ERROR ;
	619	}
	620	return code ;
	621	}
	622
	623	enum{
	624	INITIAL_ORDER,
	625	ERROR_ORDER,
	626	TYPE_ORDER,
	627	TIME_ORDER
	628	} ;
	629
	630	/*
	631	* Enregistre les erreurs de fin d'assemblage
	632	*/
	633	void PrintErrorList(void)
	634	{
	635	int i = 0 ;
	636	struct ERRLIST *current_error ;
	637
	638	current_error = first_error ;
	639	while((current_error = current_error->next) != NULL)
	640	i++ ;
	641	printf("\n%06d Total Errors\n",i) ;
	642	fprintf(fp_lst, "\n%06d Total Errors\n",i) ;
	643
	644	if (i != 0)
	645	{
	646	current_error = first_error ;
	647	switch(scan.err_order)
	648	{
	649	case INITIAL_ORDER :
	650	current_error = first_error ;
	651	while((current_error = current_error->next) != NULL)
	652	PrintErrorListLine(current_error) ;
	653	break ;
	654	case ERROR_ORDER :
	655	for(i=0;i<ETSIZE;i++)
	656	{
	657	current_error = first_error ;
	658	while((current_error = current_error->next) != NULL)
	659	if (current_error->error == i)
	660	PrintErrorListLine(current_error) ;
	661	}
	662	break ;
	663	}
	664	}
	665	}
	666
	667
	668	/***********************************************************************
	669	*
	670	* Lecture d'un argument
	671	*
	672	***********************************************************************/
	673
	674	/*
	675	* Teste si caractère alphabétique
	676	*/
	677	int is_alpha(unsigned char c)
	678	{
	679	switch(scan.soft)
	680	{
	681	case SOFT_ASSEMBLER :
	682	return ((upper_case(c) >= 'A') && (upper_case(c) <= 'Z')) ? TRUE : FALSE ;
	683	break ;
	684	default :
	685	return (((upper_case(c) >= 'A') && (upper_case(c) <= 'Z'))
	686	\|\| (c == '_')) ? TRUE : FALSE ;
	687	break ;
	688	}
	689	return FALSE ;
	690	}
	691
	692	/*
	693	* Teste si caractère numérique
	694	*/
	695	int is_numeric(unsigned char c)
	696	{
	697	return ((c >= '0') && (c <= '9')) ? TRUE : FALSE ;
	698	}
	699
	700	/* Les valeurs de registres sont dans l'ordre pour TFR/EXG */
	701	enum {
	702	REG_D = 0x00,
	703	REG_X,
	704	REG_Y,
	705	REG_U,
	706	REG_S,
	707	REG_PC,
	708	REG_A = 0x08,
	709	REG_B,
	710	REG_CC,
	711	REG_DP,
	712	REG_PCR = 0x0F,
	713	NUMERIC_CHAR,
	714	ALPHA_CHAR,
	715	SIGN_CHAR
	716	} ;
	717
	718	/* Le bit ISREG set à déterminer s'il s'agit d'un registre hors PCR */
	719	enum {
	720	END_CHAR,
	721	ISREG = 0x8000,
	722	REGS_PCR = 0x0004,
	723	REGS_CCDPPC = 0x8005,
	724	REGS_ABD,
	725	REGS_XYUS
	726	} ;
	727
	728	int ScanLine(void)
	729	{
	730	int i ;
	731	char *p ;
	732	char regbuf[4] ;
	733
	734	const struct {
	735	char name[4] ; /* Nom du registre */
	736	int code ; /* Code du registre */
	737	int group ; /* Code du groupe du registre */
	738	} Regs_T[11] = {
	739	{ "A", REG_A , REGS_ABD },
	740	{ "B", REG_B , REGS_ABD },
	741	{ "D", REG_D , REGS_ABD },
	742	{ "X", REG_X , REGS_XYUS },
	743	{ "Y", REG_Y , REGS_XYUS },
	744	{ "U", REG_U , REGS_XYUS },
	745	{ "S", REG_S , REGS_XYUS },
	746	{ "CC", REG_CC , REGS_CCDPPC },
	747	{ "DP", REG_DP , REGS_CCDPPC },
	748	{ "PC", REG_PC , REGS_CCDPPC },
	749	{ "PCR", REG_PCR, REGS_PCR }
	750	} ;
	751	#define RTSIZE (int)sizeof(Regs_T)/(int)sizeof(Regs_T[0])
	752
	753	*arg = '\0' ;
	754	if (*line <= ' ') return END_CHAR ;
	755
	756	/* Capture d'au moins un caractère jusqu'à fin élément */
	757	p = arg ;
	758	i = 0 ;
	759	if ((is_alpha(line) == TRUE) \|\| (is_numeric(line) == TRUE))
	760	{
	761	while (((is_alpha(line) == TRUE) \|\| (is_numeric(line) == TRUE)) && (i < 41))
	762	{
	763	(p++) = (line++) ;
	764	i++ ;
	765	}
	766	while ((is_alpha(line) == TRUE) \|\| (is_numeric(line) == TRUE))
	767	line++ ;
	768	}
	769	else (p++) = (line++) ;
	770
	771	*p = '\0' ;
	772
	773	/* Si alphabétique */
	774	if (is_alpha(*arg) == TRUE)
	775	{
	776	if ((int)strlen(arg) < 4)
	777	{
	778	regbuf[0] = '\0' ;
	779	strcat(regbuf,arg) ;
	780	upper_string(regbuf) ;
	781	for(i=0;i<RTSIZE;i++)
	782	if (!strcmp(regbuf,Regs_T[i].name)) {
	783	run.regcode = Regs_T[i].code ;
	784	return (Regs_T[i].group) ; }
	785	}
	786	return ALPHA_CHAR ;
	787	}
	788
	789	/* Si numérique */
	790	if (is_numeric(*arg) == TRUE) return NUMERIC_CHAR ;
	791
	792	/* Sinon, signe */
	793	return SIGN_CHAR ;
	794	}
	795
	796
	797	/***********************************************************************
	798	*
	799	* Enregistrement de la ligne de code dans le listing
	800	*
	801	***********************************************************************/
	802
	803	#define CODE_STRING_SIZE 18
	804
	805	enum{
	806	PRINT_EMPTY,
	807	PRINT_LINE,
	808	PRINT_NO_CODE,
	809	PRINT_BYTES,
	810	PRINT_BYTES_ONLY,
	811	PRINT_WORDS,
	812	PRINT_WORDS_ONLY,
	813	PRINT_PC,
	814	PRINT_LIKE_END,
	815	PRINT_LIKE_DP,
	816	PRINT_ONE_FOR_ONE,
	817	PRINT_TWO_FOR_TWO,
	818	PRINT_TWO_FOR_THREE,
	819	PRINT_THREE_FOR_THREE,
	820	PRINT_THREE_FOR_FOUR
	821	} ;
	822
	823	/*
	824	* Enregistre la ligne de code
	825	*/
	826	int RecordLine(int drawmode)
	827	{
	828	int i ;
	829	int size ;
	830	char opcodestring[5] ;
	831	char bytestring[6] ;
	832	char codestring[CODE_STRING_SIZE+2] ;
	833	char cyclestring[6] ;
	834	char formatstring[LINE_MAX_SIZE+3] ;
	835	char fmt[20] ;
	836
	837	if (run.pass != PASS2) return NO_ERROR ;
	838
	839	if (run.locked) drawmode = PRINT_NO_CODE ;
	840
	841	/* Prépare la chaîne de l'opcode */
	842	if (run.code[0])
	843	sprintf(opcodestring,"%02X%02X",run.code[0],run.code[1]) ;
	844	else
	845	sprintf(opcodestring,"%02X ",run.code[1]) ;
	846
	847	/* Prépare la chaîne des cycles */
	848	cyclestring[0] = '\0' ;
	849	if ((drawmode != PRINT_NO_CODE) && (info.cycle.count != -1))
	850	{
	851	if (info.cycle.plus != -1)
	852	sprintf(cyclestring,"%d+%d",
	853	info.cycle.count,
	854	info.cycle.plus) ;
	855	else
	856	sprintf(cyclestring,"%d",info.cycle.count) ;
	857	}
	858
	859	formatstring[0] = '\0' ;
	860	codestring[0] = '\0' ;
	861
	862	switch(drawmode)
	863	{
	864	case PRINT_EMPTY :
	865	case PRINT_NO_CODE :
	866	break ;
	867	case PRINT_BYTES :
	868	case PRINT_BYTES_ONLY :
	869	case PRINT_WORDS :
	870	case PRINT_WORDS_ONLY :
	871	size = ((drawmode == PRINT_BYTES) \|\| (drawmode == PRINT_BYTES_ONLY)) ? 1 : 2 ;
	872	sprintf(codestring,"%04X ",run.pc) ;
	873	for(i=0;i<run.size;i+=size)
	874	{
	875	if (i != 0) strcat(codestring," ") ;
	876	if (size == 1)
	877	sprintf(bytestring,"%02X",run.code[i+1]) ;
	878	else
	879	sprintf(bytestring,"%02X%02X",run.code[i+1],run.code[i+2]) ;
	880	strcat(codestring,bytestring) ;
	881	}
	882	break ;
	883	case PRINT_PC :
	884	sprintf(codestring,"%04X",run.pc) ;
	885	break ;
	886	case PRINT_LIKE_END :
	887	sprintf(codestring,"%10s%04X","",(unsigned short)eval.operand) ;
	888	break ;
	889	case PRINT_LIKE_DP :
	890	sprintf(codestring,"%10s%02X","",run.dp) ;
	891	break ;
	892	case PRINT_ONE_FOR_ONE :
	893	sprintf(codestring,"%04X %s",
	894	run.pc,
	895	opcodestring) ;
	896	break ;
	897	case PRINT_TWO_FOR_TWO :
	898	sprintf(codestring,"%04X %s %02X",
	899	run.pc,
	900	opcodestring,
	901	run.code[2]) ;
	902	break ;
	903	case PRINT_TWO_FOR_THREE :
	904	sprintf(codestring,"%04X %s %02X%02X",
	905	run.pc,
	906	opcodestring,
	907	run.code[2],
	908	run.code[3]) ;
	909	break ;
	910	case PRINT_THREE_FOR_THREE :
	911	sprintf(codestring,"%04X %s %02X %02X",
	912	run.pc,
	913	opcodestring,
	914	run.code[2],
	915	run.code[3]) ;
	916	break ;
	917	case PRINT_THREE_FOR_FOUR :
	918	sprintf(codestring,"%04X %s %02X %02X%02X",
	919	run.pc,
	920	opcodestring,
	921	run.code[2],
	922	run.code[3],
	923	run.code[4]) ;
	924	break ;
	925	}
	926
	927	switch(drawmode)
	928	{
	929	case PRINT_EMPTY :
	930	sprintf(formatstring,"% 7d",run.line) ;
	931	break ;
	932	case PRINT_BYTES_ONLY :
	933	case PRINT_WORDS_ONLY :
	934	sprintf(formatstring,"%14s %s","",codestring) ;
	935	break ;
	936	default :
	937	sprintf(fmt,"%% 7d %%-5s %%-%ds ",CODE_STRING_SIZE) ;
	938	sprintf(formatstring,fmt,run.line,cyclestring,codestring) ;
	939	MakeLimitedLine(formatstring) ;
	940	break ;
	941	}
	942
	943	fprintf(fp_lst,"%s\n",formatstring) ;
	944
	945	/* Affiche la ligne de code dans la fenêtre si WL */
	946	if (run.opt[OPT_WL] == TRUE)
	947	printf("%s\n",formatstring) ;
	948
	949	return NO_ERROR ;
	950	}
	951
	952
	953	/***********************************************************************
	954	*
	955	* Opérations disque pour le fichier binaire
	956	*
	957	***********************************************************************/
	958
	959	FILE *fp_bin ;
	960
	961	enum{
	962	BIN_FILE,
	963	LINEAR_FILE,
	964	HYBRID_FILE,
	965	DATA_FILE
	966	} ;
	967
	968	struct {
	969	char flag ; /* Flag on/off binaire */
	970	size_t size ; /* Taille du hunk */
	971	size_t addr ; /* Adresse du hunk */
	972	char data; / Buffer de hunk */
	973	int type ; /* Type de fichier : BIN_FILE/LINEAR_FILE/DATA_FILE */
	974	long int pos ; /* Position du header précédent */
	975	} bin ;
	976
	977	/*
	978	* Sauve le header de fichier binaire
	979	*/
	980	void SaveBinHeader(char flag, size_t size, size_t addr)
	981	{
	982	fputc (flag, fp_bin) ;
	983	fputc (size >> 8, fp_bin) ;
	984	fputc (size, fp_bin) ;
	985	fputc (addr >> 8, fp_bin) ;
	986	fputc (addr, fp_bin) ;
	987	}
	988
	989	/*
	990	* Sauve éventuellement le bloc courant
	991	*/
	992	void SaveBinBlock(void)
	993	{
	994	if (bin.size != 0)
	995	{
	996	switch (bin.type)
	997	{
	998	case DATA_FILE :
	999	if ((size_t)run.pc != (bin.addr + bin.size))
	1000	PrintError (ERR_BINARY_NOT_LINEAR) ;
	1001	break;
	1002
	1003	case LINEAR_FILE :
	1004	/* if (bin.size > 0xFFFF) */
	1005	if ((size_t)run.pc != (bin.addr + bin.size))
	1006	PrintError (ERR_BINARY_NOT_LINEAR) ;
	1007	SaveBinHeader (bin.flag, bin.size, bin.addr) ;
	1008	break;
	1009
	1010	default :
	1011	SaveBinHeader (bin.flag, bin.size, bin.addr) ;
	1012	break;
	1013	}
	1014	fwrite (bin.data, sizeof(char), bin.size, fp_bin) ;
	1015	}
	1016	}
	1017
	1018
	1019	/*
	1020	* Sauve une donnée binaire
	1021	*/
	1022	void SaveBinChar(unsigned char c)
	1023	{
	1024	if ((run.pass == PASS2)
	1025	&& (run.locked == UNLOCKED)
	1026	&& (run.opt[OPT_NO] == FALSE))
	1027	{
	1028	if (((size_t)run.pc != (bin.addr + bin.size))
	1029	\|\| ((bin.type == BIN_FILE) && (bin.size == 0x0080))
	1030	\|\| (bin.size == 0xffff)
	1031	\|\| (bin.size == 0x0000))
	1032	{
	1033	/* Sauve éventuellement le bloc courant */
	1034	SaveBinBlock() ;
	1035
	1036	/* Initialise le bloc suivant */
	1037	bin.flag = 0x00 ;
	1038	bin.size = 0x0000 ;
	1039	bin.addr = run.pc ;
	1040	}
	1041	bin.data[bin.size++] = c ;
	1042	}
	1043	run.pc++ ;
	1044	info.size++ ;
	1045	check[1][1]++ ;
	1046	}
	1047
	1048	/*
	1049	* Ferme le fichier binaire
	1050	*/
	1051	void CloseBin(void)
	1052	{
	1053	/* Sauve éventuellement le bloc courant */
	1054	SaveBinBlock() ;
	1055
	1056	/* Sauve éventuellement le bloc de clôture */
	1057	if (bin.type != DATA_FILE)
	1058	SaveBinHeader((char)0xFF,0x00,run.exec) ;
	1059	if (bin.data != NULL)
	1060	{
	1061	free (bin.data);
	1062	bin.data = NULL;
	1063	}
	1064	fclose(fp_bin) ;
	1065	}
	1066
	1067	/*
	1068	* Ouvre le fichier binaire
	1069	*/
	1070	int OpenBin(char *name)
	1071	{
	1072	bin.data = NULL;
	1073	bin.size = 0x0000 ;
	1074	if ((fp_bin = fopen(name,"wb")) == NULL)
	1075	return PrintError(ERR_IO_ERROR) ;
	1076	bin.data = (char *)malloc(65536);
	1077
	1078	return NO_ERROR ;
	1079	}
	1080
	1081
	1082	/***********************************************************************
	1083	*
	1084	* Traitement des symboles
	1085	*
	1086	***********************************************************************/
	1087
	1088	enum{
	1089	ARG_VALUE,
	1090	READ_VALUE,
	1091	SET_VALUE,
	1092	EQU_VALUE,
	1093	LABEL_VALUE,
	1094	MACRO_VALUE
	1095	} ;
	1096
	1097	struct SYMBLIST {
	1098	struct SYMBLIST *next ;
	1099	char name[ARG_MAX_SIZE+2] ; /* Nom du symbole */
	1100	unsigned short value ; /* Valeur du symbole */
	1101	int error ; /* NO_ERROR/ERR_EXPRESSION_ERROR/ERR_MULTIPLY_DEFINED_SYMBOL */
	1102	int type ; /* SET_VALUE/EQU_VALUE/LABEL_VALUE/MACRO_VALUE */
	1103	int time ; /* Compteur d'apparition */
	1104	int pass ; /* Numéro de pass de la dernière définition */
	1105	} ;
	1106
	1107	struct SYMBLIST *first_symbol ;
	1108
	1109	/*
	1110	* Initialise le chaînage des symboles
	1111	*
	1112	* Le premier élément de la liste (pointé par first_symbol) ne contient
	1113	* éventuellement qu'un pointeur 'next', et le premier caractère de son
	1114	* nom est '\0'
	1115	* Ainsi, le pointeur first_symbol est invariable
	1116	*/
	1117	void InitSymbolChain(void)
	1118	{
	1119	first_symbol = malloc(sizeof(struct SYMBLIST)) ;
	1120	first_symbol->next = NULL ;
	1121	first_symbol->name[0] = '\0' ;
	1122	}
	1123
	1124	/*
	1125	* Libère la mémoire pour le chaînage des symboles
	1126	*/
	1127	void FreeSymbolChain(void)
	1128	{
	1129	struct SYMBLIST *current_symbol ;
	1130	while ((current_symbol = first_symbol))
	1131	{
	1132	first_symbol = first_symbol->next ;
	1133	free(current_symbol) ;
	1134	}
	1135	}
	1136
	1137	/* Compare deux noms de symboles
	1138	* Le programme renvoie 5 valeurs :
	1139	* -2 = le 1er nom est inférieur (majuscule != minuscule)
	1140	* -1 = le 1er nom est inférieur (majuscule = minuscule)
	1141	* 0 = les deux noms sont égaux
	1142	* 1 = le 1er nom est supérieur (majuscule = minuscule)
	1143	* 2 = le 1er nom est supérieur (majuscule != minuscule)
	1144	*/
	1145	int CompareSymbolNames(char string1, char string2)
	1146	{
	1147	int i = 0, j = 0 ;
	1148
	1149	while((*(string1+i) != '\0')
	1150	&& (*(string2+i) != '\0')
	1151	&& ((string1+i) == (string2+i)))
	1152	i++ ;
	1153
	1154	j = i ;
	1155	while((*(string1+j) != '\0')
	1156	&& (*(string2+j) != '\0')
	1157	&& (upper_case((string1+j)) == upper_case((string2+j))))
	1158	j++ ;
	1159
	1160	if (upper_case((string1+j)) < upper_case((string2+j))) return -1 ;
	1161	if (upper_case((string1+j)) > upper_case((string2+j))) return 1 ;
	1162	if ((string1+i) < (string2+i)) return -2 ;
	1163	if ((string1+i) > (string2+i)) return 2 ;
	1164	return 0 ;
	1165	}
	1166
	1167	/*
	1168	* - Ajoute éventuellement un symbole à la liste
	1169	* - Met éventuellement le symbole à jour
	1170	* - Lit le symbole
	1171	*/
	1172	int DoSymbol(char *name, unsigned short value, int type)
	1173	{
	1174	int match = 0 ;
	1175	struct SYMBLIST *prev_symbol = NULL ;
	1176	struct SYMBLIST *insert_symbol = NULL ;
	1177	struct SYMBLIST *found_symbol = NULL ;
	1178	struct SYMBLIST *new_symbol = NULL ;
	1179
	1180	/* Recherche le symbole dans la liste
	1181	* Le programme en profite pour ranger les symboles dans l'ordre
	1182	* alphabétique sans distinction entre majuscule et minuscule */
	1183	insert_symbol = NULL ;
	1184	found_symbol = first_symbol ;
	1185	do {
	1186	if (insert_symbol == NULL)
	1187	prev_symbol = found_symbol ;
	1188	if ((found_symbol = found_symbol->next) != NULL)
	1189	{
	1190	match = CompareSymbolNames(name,found_symbol->name) ;
	1191	if ((match == -1) \|\| (match == 0))
	1192	insert_symbol = found_symbol ;
	1193	}
	1194	} while((found_symbol != NULL) && (match > 0)) ;
	1195
	1196	/* Si trouvé */
	1197	if ((found_symbol != NULL) && (match == 0))
	1198	{
	1199	/* Actualise le pass si argument de commande */
	1200	if (found_symbol->type == ARG_VALUE)
	1201	found_symbol->pass = run.pass ;
	1202
	1203	if (type == READ_VALUE)
	1204	{
	1205	eval.type = (found_symbol->type == ARG_VALUE) ? EQU_VALUE : found_symbol->type ;
	1206	eval.operand = found_symbol->value ;
	1207	if (found_symbol->pass < run.pass)
	1208	eval.pass = found_symbol->pass ;
	1209	switch(run.pass)
	1210	{
	1211	case PASS1 :
	1212	found_symbol->time++ ;
	1213	break ;
	1214	case PASS2 :
	1215	if ((found_symbol->time == 0)
	1216	&& (run.opt[OPT_OP] == TRUE))
	1217	PrintError(ERR_LONE_SYMBOL) ;
	1218	if (found_symbol->error != NO_ERROR)
	1219	return PrintError(found_symbol->error) ;
	1220	break ;
	1221	}
	1222	}
	1223	else
	1224	{
	1225	switch(run.pass)
	1226	{
	1227	case PASS1 :
	1228	/* Mise à jour si symbole non défini */
	1229	if ((found_symbol->pass) == MACROPASS)
	1230	{
	1231	found_symbol->pass = PASS1 ;
	1232	found_symbol->type = type ;
	1233	found_symbol->error = NO_ERROR ;
	1234	found_symbol->value = value ;
	1235	}
	1236	/* Si symboles de même valeur et de même nature ou SET,
	1237	* mise à jour de la valeur, sinon répertorie une erreur */
	1238	if (((found_symbol->type == SET_VALUE)
	1239	\|\| (found_symbol->value == value))
	1240	&& (found_symbol->type == type))
	1241	found_symbol->value = value ;
	1242	else
	1243	found_symbol->error = ERR_MULTIPLY_DEFINED_SYMBOL ;
	1244	break ;
	1245	case PASS2 :
	1246	/* Mise à jour du pass */
	1247	if ((found_symbol->pass) == PASS1)
	1248	found_symbol->pass = PASS2 ;
	1249	/* Mise à jour si SET */
	1250	if (found_symbol->type == SET_VALUE)
	1251	found_symbol->value = value ;
	1252	/* Affiche éventuellement l'erreur */
	1253	if (found_symbol->error != NO_ERROR)
	1254	return PrintError(found_symbol->error) ;
	1255	break ;
	1256	}
	1257	}
	1258	}
	1259
	1260	/* Si pas trouvé */
	1261	else
	1262	{
	1263	if ((run.pass == PASS1)
	1264	\|\| (type == ARG_VALUE))
	1265	{
	1266	/* Positionne l'enregistrement dans la liste */
	1267	new_symbol = malloc(sizeof(struct SYMBLIST)) ;
	1268	if (insert_symbol == NULL)
	1269	insert_symbol = prev_symbol ;
	1270	else
	1271	if (CompareSymbolNames(name,insert_symbol->name) < 0)
	1272	insert_symbol = prev_symbol ;
	1273	/* Enregistre le symbole */
	1274	new_symbol->next = insert_symbol->next ;
	1275	insert_symbol->next = new_symbol ;
	1276	new_symbol->name[0] = '\0' ;
	1277	strcat(new_symbol->name,name) ;
	1278	new_symbol->value = value ;
	1279	new_symbol->error = NO_ERROR ;
	1280	new_symbol->type = type ;
	1281	new_symbol->time = 0 ;
	1282	new_symbol->pass = PASS1 ;
	1283	if (type == READ_VALUE)
	1284	{
	1285	new_symbol->type = EQU_VALUE ;
	1286	new_symbol->pass = MACROPASS ;
	1287	new_symbol->time++ ;
	1288	new_symbol->error = ERR_EXPRESSION_ERROR ;
	1289	}
	1290	eval.pass = new_symbol->pass ;
	1291	eval.type = EQU_VALUE ;
	1292	}
	1293	else
	1294	return PrintError(ERR_SYMBOL_ERROR) ;
	1295	}
	1296
	1297	return NO_ERROR ;
	1298	}
	1299
	1300	/*
	1301	* Enregistre une ligne de symbole de fin d'assemblage
	1302	*/
	1303	void PrintSymbolLine(struct SYMBLIST *slist)
	1304	{
	1305	const struct {
	1306	char string[9] ; /* Message de l'erreur */
	1307	int type ; /* Code de l'erreur */
	1308	} ErrorTable[3] = {
	1309	{ " ", NO_ERROR },
	1310	{ "Unknown ", ERR_EXPRESSION_ERROR },
	1311	{ "Multiply", ERR_MULTIPLY_DEFINED_SYMBOL }
	1312	} ;
	1313
	1314	const struct {
	1315	char string[6] ; /* Message du type de valeur */
	1316	int type ; /* Type de la valeur */
	1317	} TypeTable[6] = {
	1318	{ "Arg ", ARG_VALUE },
	1319	{ "Equ ", EQU_VALUE },
	1320	{ "Set ", SET_VALUE },
	1321	{ "Label", LABEL_VALUE },
	1322	{ "Macro", MACRO_VALUE }
	1323	} ;
	1324
	1325	int error = 0 ;
	1326	int type = 0 ;
	1327	char errorstring[LINE_MAX_SIZE+2] ;
	1328
	1329	while(slist->error != ErrorTable[error].type) error++ ;
	1330	while(slist->type != TypeTable[type].type) type++ ;
	1331
	1332	sprintf(errorstring, "% 6dx %s %s %04X %s",
	1333	slist->time,
	1334	ErrorTable[error].string,
	1335	TypeTable[type].string,
	1336	(unsigned short)slist->value,
	1337	slist->name) ;
	1338	fprintf(fp_lst, "%s\n", errorstring) ;
	1339	/* Affiche la ligne si WS */
	1340	if (run.opt[OPT_WS] == TRUE)
	1341	printf("%s\n", errorstring) ;
	1342	}
	1343
	1344
	1345	/*
	1346	* Enregistre les symboles de fin d'assemblage
	1347	*/
	1348	void PrintSymbolList(void)
	1349	{
	1350	int ErrorOrderList[] = {
	1351	ERR_EXPRESSION_ERROR,
	1352	ERR_MULTIPLY_DEFINED_SYMBOL,
	1353	NO_ERROR
	1354	} ;
	1355	int TypeOrderList[] = {
	1356	ARG_VALUE,
	1357	EQU_VALUE,
	1358	SET_VALUE,
	1359	LABEL_VALUE,
	1360	MACRO_VALUE
	1361	} ;
	1362	int i = 0 ;
	1363	int time = 0, nexttime = 0, prevtime = 0 ;
	1364	struct SYMBLIST *current_symbol ;
	1365
	1366	/* Compte les symboles */
	1367	current_symbol = first_symbol ;
	1368	while((current_symbol = current_symbol->next) != NULL) i++ ;
	1369
	1370	/* Affiche si au moins un symbole */
	1371	if (i)
	1372	{
	1373	printf("\n%06d Total Symbols\n",i) ;
	1374	fprintf(fp_lst, "\n%06d Total Symbols\n",i) ;
	1375
	1376	switch(scan.symb_order)
	1377	{
	1378	case INITIAL_ORDER :
	1379	current_symbol = first_symbol ;
	1380	while((current_symbol = current_symbol->next) != NULL)
	1381	PrintSymbolLine(current_symbol) ;
	1382	break ;
	1383	case ERROR_ORDER :
	1384	for(i=0;i<3;i++)
	1385	{
	1386	current_symbol = first_symbol ;
	1387	while((current_symbol = current_symbol->next) != NULL)
	1388	if (current_symbol->error == ErrorOrderList[i])
	1389	PrintSymbolLine(current_symbol) ;
	1390	}
	1391	break ;
	1392	case TYPE_ORDER :
	1393	for(i=0;i<5;i++)
	1394	{
	1395	current_symbol = first_symbol ;
	1396	while((current_symbol = current_symbol->next) != NULL)
	1397	if (current_symbol->type == TypeOrderList[i])
	1398	PrintSymbolLine(current_symbol) ;
	1399	}
	1400	break ;
	1401	case TIME_ORDER :
	1402	do
	1403	{
	1404	prevtime = nexttime ;
	1405	nexttime = 0x7FFFFFFF ;
	1406	current_symbol = first_symbol ;
	1407	while((current_symbol = current_symbol->next) != NULL)
	1408	{
	1409	if ((current_symbol->time > time)
	1410	&& (current_symbol->time < nexttime))
	1411	nexttime = current_symbol->time ;
	1412	if (current_symbol->time == time)
	1413	PrintSymbolLine(current_symbol) ;
	1414	}
	1415	time = nexttime ;
	1416	} while(nexttime != prevtime) ;
	1417	break ;
	1418	}
	1419	fprintf(fp_lst,"\n") ;
	1420	}
	1421	}
	1422
	1423
	1424	/***********************************************************************
	1425	*
	1426	* Evaluateur d'opérande
	1427	*
	1428	***********************************************************************/
	1429
	1430	struct EVALLIST {
	1431	struct EVALLIST prev ; / Pointeur sur section précédente */
	1432	char sign ; /* Signe opérateur */
	1433	int priority ; /* Priorité de l'opérateur */
	1434	int operand ; /* Valeur opérande */
	1435	} ;
	1436
	1437	struct EVALLIST *current_eval = NULL ;
	1438
	1439	/*
	1440	* Ajoute un chaînage à l'évaluation
	1441	*
	1442	* Le premier élément de la liste
	1443	* ne contient éventuellement qu'un
	1444	* pointeur 'next', et sa priorité
	1445	* de calcul est à 0
	1446	*/
	1447	void NewEvalChain(char sign, int priority, short operand)
	1448	{
	1449	struct EVALLIST *prev_eval ;
	1450	prev_eval = current_eval ;
	1451	current_eval = malloc(sizeof(struct EVALLIST)) ;
	1452	current_eval->prev = prev_eval ;
	1453	current_eval->sign = sign ;
	1454	current_eval->priority = priority ;
	1455	current_eval->operand = operand ;
	1456	}
	1457
	1458	/*
	1459	* Libère un maillon du chaînage d'évaluation
	1460	*/
	1461	void DeleteEvalChain(void)
	1462	{
	1463	struct EVALLIST *prev_eval ;
	1464	prev_eval = current_eval->prev ;
	1465	free(current_eval) ;
	1466	current_eval = prev_eval ;
	1467	}
	1468
	1469	/*
	1470	* Libère le chaînage d'évaluation
	1471	*/
	1472	int FreeEvalChain(int error)
	1473	{
	1474	while(current_eval != NULL)
	1475	DeleteEvalChain() ;
	1476	return error ;
	1477	}
	1478
	1479	/*
	1480	* Lecture d'une valeur d'opérande
	1481	*/
	1482	int ReadValue(void)
	1483	{
	1484	int i ;
	1485	unsigned char c ;
	1486	char base, prefix_base, suffix_base ;
	1487	char *p ;
	1488	char sign = 0 ;
	1489
	1490	eval.operand = 0 ;
	1491
	1492	do
	1493	{
	1494	do
	1495	{
	1496	sign = '\0' ;
	1497	/* Cas spécial de '.NOT.' */
	1498	if (*line == '.')
	1499	{
	1500	p = line++ ;
	1501	i = ScanLine() ;
	1502	upper_string(arg) ;
	1503	if ((i == ALPHA_CHAR)
	1504	&& (!strcmp("NOT",arg))
	1505	&& (*line == '.'))
	1506	{
	1507	if (scan.soft != SOFT_ASSEMBLER)
	1508	return PrintError(ERR_EXPRESSION_ERROR) ;
	1509	line++ ;
	1510	sign = ':' ;
	1511	}
	1512	else line = p ;
	1513	}
	1514	else
	1515
	1516	/* Repérage des opérateurs de signe */
	1517	if ((*line == '+')
	1518	\|\| (*line == '-')
	1519	\|\| (*line == ':'))
	1520	{
	1521	sign = *(line++) ;
	1522	if ((sign == ':') && (scan.soft == SOFT_ASSEMBLER))
	1523	return PrintError(ERR_EXPRESSION_ERROR) ;
	1524	}
	1525	/* Enregistre éventuellement le signe */
	1526	if (sign)
	1527	NewEvalChain(sign,0x80,0) ;
	1528	} while(sign) ;
	1529
	1530	sign = 0 ;
	1531	if (*line == '(')
	1532	{
	1533	/* Enregistre la parenthèse ouvrante */
	1534	line++ ;
	1535	NewEvalChain('\0',0,0) ;
	1536	sign = '(' ;
	1537	}
	1538	} while(sign) ;
	1539
	1540	/* Récupération d'une valeur numérique :
	1541	* (0-9, $, %, @ ou &)nombre(U, Q, O, T ou H)
	1542	* Les bases préfixées et suffixées peuvent être déterminées
	1543	* toutes deux, mais il y a erreur si elles ne correspondent
	1544	* pas.
	1545	*/
	1546
	1547	if ((is_numeric(*line) == TRUE)
	1548	\|\| (*line == '&')
	1549	\|\| (*line == '@')
	1550	\|\| (*line == '%')
	1551	\|\| (*line == '$'))
	1552	{
	1553	prefix_base = 0 ;
	1554	if (ScanLine() == SIGN_CHAR)
	1555	{
	1556	switch(*arg)
	1557	{
	1558	case '%': prefix_base = 2 ; break ;
	1559	case '@': prefix_base = 8 ; break ;
	1560	case '&': prefix_base = 10 ; break ;
	1561	case '$': prefix_base = 16 ; break ;
	1562	}
	1563	ScanLine() ;
	1564	}
	1565	suffix_base = 0 ;
	1566	switch (upper_case(*(arg + (int)strlen(arg) - 1)))
	1567	{
	1568	case 'U': suffix_base = 2 ; break ;
	1569	case 'Q':
	1570	case 'O': suffix_base = 8 ; break ;
	1571	case 'T': suffix_base = 10 ; break ;
	1572	case 'H': suffix_base = 16 ; break ;
	1573	}
	1574
	1575	/* Le rapport préfixe/suffixe est valide si au
	1576	* moins l'un des deux est indéfini ou s'ils
	1577	* sont égaux */
	1578	if ((prefix_base != 0)
	1579	&& (suffix_base != 0)
	1580	&& (suffix_base != prefix_base))
	1581	return PrintError(ERR_EXPRESSION_ERROR) ;
	1582	/* Base 10 si ni préfixe ni suffixe définis */
	1583	if ((base = (prefix_base \| suffix_base)) == 0) base = 10 ;
	1584	/* Rejette le binaire pour ASSEMBLER */
	1585	/* Erreur si pas d'opérande */
	1586	if (((base == 2) && (scan.soft == SOFT_ASSEMBLER))
	1587	\|\| (((int)strlen(arg)-((suffix_base != 0) ? 1 : 0)) == 0))
	1588	return PrintError(ERR_EXPRESSION_ERROR) ;
	1589
	1590	for(i=0;i<(int)strlen(arg)-((suffix_base != 0) ? 1 : 0);i++)
	1591	{
	1592	if ((arg[i] > '9') && (arg[i] < 'A'))
	1593	return PrintError(ERR_EXPRESSION_ERROR) ;
	1594	c = (arg[i] < 'A') ? arg[i] -'0' : upper_case(arg[i]) -'A' + 10 ;
	1595	if (c >= base) return PrintError(ERR_EXPRESSION_ERROR) ;
	1596	eval.operand = (eval.operand * base) + c ;
	1597	}
	1598	}
	1599
	1600	/* Récupération de la valeur du pointeur de programme
	1601	* '.' ou '' /
	1602	else
	1603	if ((line == '.') \|\| (line == '*'))
	1604	{
	1605	eval.operand = run.pc ;
	1606	line++ ;
	1607	}
	1608
	1609	/* Récupération d'une valeur ASCII
	1610	* '[caractère]['caractère]
	1611	* Une apostrophe sèche donne 0x0D
	1612	* Doublet de déclaration seulement pour MACROASSEMBLER
	1613	*/
	1614	else
	1615	if (*line == '\'')
	1616	{
	1617	eval.operand = 0 ;
	1618	for(i=0;i<2;i++)
	1619	{
	1620	if (*line == '\'')
	1621	{
	1622	line++ ;
	1623	c = *line ;
	1624	if (((i == 1) && (scan.soft == SOFT_ASSEMBLER))
	1625	\|\| (c > 0x7F))
	1626	return PrintError(ERR_EXPRESSION_ERROR) ;
	1627	if ((c == 0x00) \|\| (c == 0x20)) c = 0x0D ;
	1628	else {
	1629	if (c == CHAR127) c = 0x20 ;
	1630	line++ ; }
	1631	eval.operand = (eval.operand << 8) \| c ;
	1632	}
	1633	}
	1634	}
	1635	else
	1636
	1637	/* Récupèration d'une valeur de symbole */
	1638	if (is_alpha(*line) == TRUE)
	1639	{
	1640	ScanLine() ;
	1641	if (scan.soft == SOFT_ASSEMBLER) upper_string(arg) ;
	1642	if (DoSymbol (arg, 0, READ_VALUE) != NO_ERROR)
	1643	return ERR_ERROR ;
	1644	if (eval.type == MACRO_VALUE)
	1645	return PrintError(ERR_OPERAND_IS_MACRO) ;
	1646	}
	1647
	1648	/* Pas de récupération possible */
	1649	else
	1650	return PrintError(ERR_MISSING_OPERAND) ;
	1651
	1652	return NO_ERROR ;
	1653	}
	1654
	1655
	1656	/*
	1657	* Lecture d'un signe opérateur
	1658	*/
	1659
	1660	int ReadOperator(void)
	1661	{
	1662	/* Pour NEQ, l'opérateur "\|" est arbitraire, celui-ci n'existant
	1663	* dans aucun des deux assembleurs sur Thomson
	1664	* Il sert seulement à faciliter le repérage de l'opérateur
	1665	* '.NOT.' est repéré mais rejeté
	1666	*/
	1667	const struct {
	1668	char string[4] ; /* Nom ASSEMBLER de l'opérateur */
	1669	char sign ; /* Signe de l'opérateur */
	1670	int priority ; /* Priorité de l'opérateur */
	1671	int compatibility ; /* Compatibilté du signe avec ASSEMBLER */
	1672	} AlphaOperator[12] = {
	1673	{ " " , '<' , 5, TRUE },
	1674	{ "EQU" , '=' , 1, TRUE },
	1675	{ "DIV" , '/' , 5, TRUE },
	1676	{ "AND" , '&' , 4, TRUE },
	1677	{ " " , '+' , 2, TRUE },
	1678	{ " " , '-' , 2, TRUE },
	1679	{ " " , '*' , 5, TRUE },
	1680	{ "OR" , '!' , 3, TRUE },
	1681	{ "NEQ" , '\|' , 1, FALSE }, /* Pas MACROASSEMBLER */
	1682	{ "NOT" , ':' , 0, FALSE }, /* Rejeté !!! */
	1683	{ "MOD" , '%' , 5, FALSE },
	1684	{ "XOR" , '^' , 3, FALSE }
	1685	} ;
	1686
	1687	int i = 0 ;
	1688
	1689	if (ScanLine() != SIGN_CHAR)
	1690	return PrintError(ERR_EXPRESSION_ERROR) ;
	1691	if (*arg == '.')
	1692	{
	1693	if ((scan.soft != SOFT_ASSEMBLER)
	1694	\|\| (ScanLine() != ALPHA_CHAR))
	1695	return PrintError(ERR_EXPRESSION_ERROR) ;
	1696	upper_string(arg) ;
	1697	i = 0 ;
	1698	while ((i < 12) && (strcmp(AlphaOperator[i].string,arg))) i++ ;
	1699	if ((i == 12) \|\| (*line != '.'))
	1700	return PrintError(ERR_EXPRESSION_ERROR) ;
	1701	eval.sign = AlphaOperator[i].sign ;
	1702	line++ ;
	1703	}
	1704	else
	1705	{
	1706	i = 0 ;
	1707	while ((i < 12) && (*arg != AlphaOperator[i].sign)) i++ ;
	1708	if ((i == 12)
	1709	\|\| (*arg == '\|')
	1710	\|\| ((AlphaOperator[i].compatibility == FALSE)
	1711	&& (scan.soft == SOFT_ASSEMBLER)))
	1712	return PrintError(ERR_EXPRESSION_ERROR) ;
	1713	eval.sign = *arg ;
	1714	}
	1715
	1716	/* Rejette 'NOT' */
	1717	if (eval.sign == ':')
	1718	return PrintError(ERR_EXPRESSION_ERROR) ;
	1719
	1720	eval.priority = AlphaOperator[i].priority ;
	1721
	1722	return NO_ERROR ;
	1723	}
	1724
	1725	/*
	1726	* Programme calculateur
	1727	*/
	1728	int CalculateEval(void)
	1729	{
	1730	unsigned short n1 = current_eval->operand,
	1731	n2 = eval.operand ;
	1732
	1733	switch(current_eval->sign)
	1734	{
	1735	case '+' : n1 += n2 ; break ;
	1736	case '-' : n1 -= n2 ; break ;
	1737	case '&' : n1 &= n2 ; break ;
	1738	case '!' : n1 \|= n2 ; break ;
	1739	case '^' : n1 ^= n2 ; break ;
	1740	case '=' : n1 = (n1 == n2) ? 0xFFFF : 0x0000 ;
	1741	break ;
	1742	case '\|' : n1 = (n1 != n2) ? 0xFFFF : 0x0000 ;
	1743	break ;
	1744	case '' : n1 = n2 ; break ;
	1745	case '/' : if (n2 == 0)
	1746	return PrintError(ERR_DIVISION_BY_ZERO) ;
	1747	else n1 /= n2 ;
	1748	break ;
	1749	case '%' : if (n2 == 0)
	1750	return PrintError(ERR_DIVISION_BY_ZERO) ;
	1751	else n1 %= n2 ;
	1752	break ;
	1753	case '<' : if ((signed short)n2 >= 0) n1 <<= n2 ; else n1 >>= (signed short)(-n2) ;
	1754	break ;
	1755	}
	1756	eval.operand = n1 ;
	1757	return NO_ERROR ;
	1758	}
	1759
	1760
	1761
	1762	/*
	1763	* Evaluation de l'opérande
	1764	*/
	1765	int Eval(void)
	1766	{
	1767	struct EVALLIST *prev_eval = NULL ;
	1768	int again = FALSE ;
	1769
	1770	eval.pass = run.pass ;
	1771
	1772	current_eval = malloc(sizeof(struct EVALLIST)) ;
	1773	current_eval->prev = NULL ;
	1774	current_eval->sign = '\0' ;
	1775	current_eval->priority = 0 ;
	1776	current_eval->operand = 0 ;
	1777
	1778	do
	1779	{
	1780	/* Récupère l'argument d'opérande */
	1781	if (ReadValue() == ERR_ERROR)
	1782	return FreeEvalChain(ERR_ERROR) ;
	1783
	1784	do
	1785	{
	1786	again = FALSE ;
	1787
	1788	/* Applique les opérateurs de signe */
	1789	while(current_eval->priority == 0x80)
	1790	{
	1791	switch(current_eval->sign)
	1792	{
	1793	case '+' : break ;
	1794	case '-' : eval.operand = -eval.operand ; break ;
	1795	case ':' : eval.operand = ~eval.operand ; break ;
	1796	}
	1797	DeleteEvalChain() ;
	1798	}
	1799
	1800	/* Exécute les parenthèses fermantes */
	1801	if (*line == ')')
	1802	{
	1803	line++ ;
	1804	/* Calcule le contenu des parenthèses*/
	1805	while(current_eval->priority != 0)
	1806	{
	1807	if (CalculateEval() != NO_ERROR)
	1808	return FreeEvalChain(ERR_ERROR) ;
	1809	eval.sign = 0 ;
	1810	eval.priority = current_eval->priority ;
	1811	DeleteEvalChain() ;
	1812	}
	1813	if (current_eval->prev == NULL)
	1814	FreeEvalChain(PrintError(ERR_EXPRESSION_ERROR)) ;
	1815	DeleteEvalChain() ;
	1816	again = TRUE ;
	1817	}
	1818	} while(again == TRUE) ;
	1819
	1820	again = FALSE ;
	1821	/* Récupère opérateur si pas fin d'opérande */
	1822	if ((*line != '\0')
	1823	&& (*line != ' ')
	1824	&& (*line != CHAR127)
	1825	&& (*line != ',')
	1826	&& (*line != ']'))
	1827	{
	1828	/* Récupère l'opérateur */
	1829	if (ReadOperator() == ERR_ERROR)
	1830	return FreeEvalChain(ERR_ERROR) ;
	1831	/* Effectue le calcul sur les priorités fortes */
	1832	if ((current_eval->priority != 0)
	1833	&& (eval.priority <= current_eval->priority))
	1834	{
	1835	while(((prev_eval = current_eval->prev) != NULL)
	1836	&& (current_eval->priority != 0)
	1837	&& (eval.priority <= current_eval->priority))
	1838	{
	1839	if (CalculateEval() != NO_ERROR)
	1840	return FreeEvalChain(ERR_ERROR) ;
	1841	DeleteEvalChain() ;
	1842	}
	1843	}
	1844	NewEvalChain(eval.sign,eval.priority,eval.operand) ;
	1845	again = TRUE ;
	1846	}
	1847	} while(again == TRUE) ;
	1848
	1849	/* Finit les calculs en fermant les sections */
	1850	while(current_eval->prev != NULL)
	1851	{
	1852	/* Erreur si parenthèse ouverte */
	1853	if (current_eval->priority == 0)
	1854	return FreeEvalChain(PrintError(ERR_EXPRESSION_ERROR)) ;
	1855	/* Effectue le calcul */
	1856	if (CalculateEval() != NO_ERROR)
	1857	return FreeEvalChain(ERR_ERROR) ;
	1858	DeleteEvalChain() ;
	1859	}
	1860	return FreeEvalChain(NO_ERROR) ;
	1861	}
	1862
	1863
	1864	/***********************************************************************
	1865	*
	1866	* Assemblage des instructions
	1867	*
	1868	***********************************************************************/
	1869
	1870	/*-------------------------------------------------------------------
	1871	* Assemblage opérande pour tout type
	1872	* Assemblage opérande pour tout type sauf immédiat
	1873	* Assemblage opérande pour LEAx
	1874	*/
	1875	int Ass_AllType(int immediate, int lea)
	1876	{
	1877	int extended_mode = FALSE ;
	1878	int direct_mode = FALSE ;
	1879	int indirect_mode = FALSE ;
	1880
	1881	unsigned char c = 0 ;
	1882	int regs ;
	1883	int mode ;
	1884	int recordtype = PRINT_NO_CODE ;
	1885
	1886	run.code[2] = 0x00 ;
	1887	run.size = 2 ;
	1888
	1889	/* Adressage immédiat */
	1890
	1891	mode = 0 ;
	1892	if (*line == '#')
	1893	{
	1894	info.cycle.count -= 2 ;
	1895	line++ ;
	1896	if (immediate == FALSE) return PrintError(ERR_EXPRESSION_ERROR) ;
	1897	if(Eval() != NO_ERROR) return ERR_ERROR ;
	1898	c = run.code[1] & 0x0F ;
	1899	if (c == 0x03) mode = 16 ;
	1900	else if ((c < 0x0C) && (c != 0x07)) mode = 8 ;
	1901	else if ((c & 0x01) == 0) mode = 16 ;
	1902	else return PrintError(ERR_BAD_OPERAND) ;
	1903	switch(mode)
	1904	{
	1905	case 8 :
	1906	run.size = 2 ;
	1907	run.code[2] = eval.operand & 0xFF ;
	1908	if ((eval.operand < -256) \|\| (eval.operand > 255))
	1909	PrintError(ERR_OPERAND_OUT_OF_RANGE) ;
	1910	return RecordLine(PRINT_TWO_FOR_TWO) ;
	1911	break ;
	1912	case 16 :
	1913	run.size = 3 ;
	1914	run.code[2] = eval.operand >> 8 ;
	1915	run.code[3] = eval.operand & 0xFF ;
	1916	return RecordLine(PRINT_TWO_FOR_THREE) ;
	1917	break ;
	1918
	1919	default :
	1920	return PrintError(ERR_BAD_OPERAND) ;
	1921	break ;
	1922	}
	1923	}
	1924
	1925	if (*line == '<') direct_mode = TRUE ;
	1926	if (*line == '>') extended_mode = TRUE ;
	1927	if ((direct_mode == TRUE) \|\| (extended_mode == TRUE)) line++ ;
	1928
	1929	if (*line == '[')
	1930	{
	1931	indirect_mode = TRUE ;
	1932	line++ ;
	1933	}
	1934
	1935	if (run.code[1] & 0x80) run.code[1] \|= 0x10 ;
	1936
	1937	/* Adressage indexé avec registre 8 bits c,z */
	1938
	1939	if (((upper_case(*line) == 'A')
	1940	\|\| (upper_case(*line) == 'B')
	1941	\|\| (upper_case(*line) == 'D'))
	1942	&& (*(line+1) == ','))
	1943	{
	1944	run.size = 2 ;
	1945	if(lea == FALSE) run.code[1] += (immediate == TRUE) ? 0x10 : 0x60 ;
	1946
	1947	if((direct_mode == TRUE) \|\| (extended_mode == TRUE))
	1948	return PrintError(ERR_BAD_OPERAND) ;
	1949
	1950	switch(upper_case(*line))
	1951	{
	1952	case 'A' : run.code[2] = 0x86 ; info.cycle.plus = 1 ; break ;
	1953	case 'B' : run.code[2] = 0x85 ; info.cycle.plus = 1 ; break ;
	1954	case 'D' : run.code[2] = 0x8B ; info.cycle.plus = 4 ; break ;
	1955	}
	1956	line += 2 ;
	1957	if (ScanLine() != REGS_XYUS)
	1958	return PrintError(ERR_BAD_OPERAND) ;
	1959	run.code[2] \|= (run.regcode - 1) << 5 ;
	1960	recordtype = PRINT_TWO_FOR_TWO ;
	1961	}
	1962
	1963	/* Adressage indexé sans offset ,z ,z+ ,z++ ,-z' ,--z */
	1964
	1965	else
	1966	if (*line == ',')
	1967	{
	1968	run.size = 2 ;
	1969	if(lea == FALSE) run.code[1] += (immediate == TRUE) ? 0x10 : 0x60 ;
	1970	line++ ;
	1971
	1972	if (*line == '-')
	1973	{
	1974	info.cycle.plus = 2 ;
	1975	run.code[2] = 0x82 ;
	1976	line++ ;
	1977	if (*line == '-')
	1978	{
	1979	info.cycle.plus = 3 ;
	1980	run.code[2] = 0x83 ;
	1981	line++ ;
	1982	}
	1983	if (ScanLine() != REGS_XYUS)
	1984	return PrintError(ERR_BAD_OPERAND) ;
	1985	}
	1986	else
	1987	if (ScanLine() == REGS_XYUS)
	1988	{
	1989	info.cycle.plus = 0 ;
	1990	run.code[2] = 0x84 ;
	1991	if (*line == '+')
	1992	{
	1993	info.cycle.plus = 2 ;
	1994	run.code[2] = 0x80 ;
	1995	line++ ;
	1996	if (*line == '+')
	1997	{
	1998	info.cycle.plus = 3 ;
	1999	run.code[2] = 0x81 ;
	2000	line++ ;
	2001	}
	2002	}
	2003	}
	2004	else
	2005	return PrintError(ERR_BAD_OPERAND) ;
	2006
	2007	run.size = 2 ;
	2008	run.code[2] \|= (run.regcode - 1) << 5 ;
	2009	if ((((run.code[2] & 0x9F) == 0x82) \|\| ((run.code[2] & 0x9F) == 0x80))
	2010	&& (indirect_mode == TRUE))
	2011	return PrintError(ERR_BAD_OPERAND) ;
	2012
	2013	recordtype = PRINT_TWO_FOR_TWO ;
	2014	}
	2015
	2016	/* Adressage indexé avec offset $xx,z $xx,PCR */
	2017
	2018	else
	2019	{
	2020	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2021
	2022	if(*line == ',')
	2023	{
	2024	if (lea == FALSE) run.code[1] += (immediate == TRUE) ? 0x10 : 0x60 ;
	2025	line++ ;
	2026	regs = ScanLine() ;
	2027
	2028	/* Adressage indexé avec offset et PCR $xx,PCR */
	2029	if (regs == REGS_PCR)
	2030	{
	2031	eval.operand -= run.pc + 3 ;
	2032	mode = ((eval.operand >= -128) && (eval.operand <= 127)) ? 8 : 16 ;
	2033	if (eval.pass < run.pass) mode = 16 ; /* 16 bits si non répertorié */
	2034	if (extended_mode == TRUE) mode = 16 ; /* 16 bits si étendu forcé */
	2035	if (direct_mode == TRUE) mode = 8 ; /* 8 bits si direct forcé */
	2036	switch(mode)
	2037	{
	2038	case 8 :
	2039	info.cycle.plus = 1 ;
	2040	run.size = 3 ;
	2041	run.code[2] = 0x8C ;
	2042	run.code[3] = eval.operand & 0xFF ;
	2043	if ((eval.operand < -128) \|\| (eval.operand > 127))
	2044	PrintError(ERR_OPERAND_OUT_OF_RANGE) ;
	2045	recordtype = PRINT_THREE_FOR_THREE ;
	2046	break ;
	2047	case 16 :
	2048	eval.operand-- ;
	2049	info.cycle.plus = 5 ;
	2050	run.size = 4 ;
	2051	run.code[2] = 0x8D ;
	2052	run.code[3] = (eval.operand >> 8) & 0xFF ;
	2053	run.code[4] = eval.operand & 0xFF ;
	2054	if (((eval.operand + 1 >= -128) && (eval.operand <= 127))
	2055	&& (run.opt[OPT_OP] == TRUE))
	2056	PrintError(ERR_8_BITS) ;
	2057	recordtype = PRINT_THREE_FOR_FOUR ;
	2058	break ;
	2059	}
	2060	}
	2061
	2062	/* Adressage indexé avec offset $xx,z */
	2063	else
	2064	if (regs == REGS_XYUS)
	2065	{
	2066	mode = 16 ;
	2067	if ((eval.operand >= -128) && (eval.operand <= 127)) mode = 8 ;
	2068	if ((eval.operand >= -16) && (eval.operand <= 15)) mode = 5 ;
	2069	if (eval.pass < run.pass) mode = 16 ; /* 16 bits si non répertorié */
	2070	if (extended_mode == TRUE) mode = 16 ; /* 16 bits si étendu forcé */
	2071	if (direct_mode == TRUE) mode = 8 ; /* 8 bits si direct forcé */
	2072	if ((mode == 5) && (indirect_mode == TRUE)) mode = 8 ;
	2073	switch(mode)
	2074	{
	2075	case 5 :
	2076	info.cycle.plus = 1 ;
	2077	run.size = 2 ;
	2078	run.code[2] = 0x00 \| (eval.operand & 0x1F) ;
	2079	recordtype = PRINT_TWO_FOR_TWO ;
	2080	break ;
	2081	case 8 :
	2082	info.cycle.plus = 1 ;
	2083	run.size = 3 ;
	2084	run.code[2] = 0x88 ;
	2085	run.code[3] = eval.operand & 0xFF ;
	2086	if ((eval.operand < -128) \|\| (eval.operand > 127))
	2087	PrintError(ERR_OPERAND_OUT_OF_RANGE) ;
	2088	recordtype = PRINT_THREE_FOR_THREE ;
	2089	break ;
	2090	case 16 :
	2091	info.cycle.plus = 4 ;
	2092	run.size = 4 ;
	2093	run.code[2] = 0x89 ;
	2094	run.code[3] = (eval.operand >> 8) & 0xFF ;
	2095	run.code[4] = eval.operand & 0xFF ;
	2096	recordtype = PRINT_THREE_FOR_FOUR ;
	2097	break ;
	2098	}
	2099	if ((run.opt[OPT_OP] == TRUE))
	2100	{
	2101	if ((eval.operand == 0)
	2102	&& (mode > 0)
	2103	&& (indirect_mode == FALSE))
	2104	PrintError(ERR_0_BIT) ;
	2105	else
	2106	if ((eval.operand >= -16)
	2107	&& (eval.operand <= 15)
	2108	&& (mode > 5)
	2109	&& (indirect_mode == FALSE))
	2110	PrintError(ERR_5_BITS) ;
	2111	else
	2112	if ((eval.operand >= -128)
	2113	&& (eval.operand <= 127)
	2114	&& (mode > 8))
	2115	PrintError(ERR_8_BITS) ;
	2116	}
	2117	run.code[2] \|= (run.regcode - 1) << 5 ;
	2118	}
	2119	else return PrintError(ERR_BAD_OPERAND) ;
	2120	}
	2121	else
	2122	{
	2123	/* Adressage direct et étendu */
	2124	if (lea == TRUE)
	2125	return PrintError(ERR_BAD_OPERAND) ;
	2126
	2127	mode = 16 ;
	2128	if (((eval.operand >> 8) & 0xFF) == run.dp) mode = 8 ; /* 8 bits si MSB = DP */
	2129	if (indirect_mode == TRUE) mode = 16 ; /* 16 bits si mode indirect */
	2130	if (eval.pass < run.pass) mode = 16 ; /* 16 bits si non répertorié */
	2131	if (extended_mode == TRUE) mode = 16 ; /* 16 bits si étendu forcé */
	2132	if (direct_mode == TRUE) mode = 8 ; /* 8 bits si direct forcé */
	2133	switch(mode)
	2134	{
	2135	case 8 :
	2136	run.size = 2 ;
	2137	run.code[2] = eval.operand & 0xFF ;
	2138	if (indirect_mode == TRUE)
	2139	return PrintError(ERR_BAD_OPERAND) ;
	2140	if (((eval.operand >> 8) & 0xFF) != run.dp)
	2141	PrintError(ERR_DP_ERROR) ;
	2142	recordtype = PRINT_TWO_FOR_TWO ;
	2143	break ;
	2144	case 16 :
	2145	if (indirect_mode == FALSE)
	2146	{
	2147	info.cycle.count++ ;
	2148	run.size = 3 ;
	2149	run.code[1] \|= (immediate == TRUE) ? 0x30 : 0x70 ;
	2150	run.code[2] = (eval.operand >> 8) & 0xFF ;
	2151	run.code[3] = eval.operand & 0xFF ;
	2152	if ((((eval.operand >> 8) & 0xFF) == run.dp)
	2153	&& (run.opt[OPT_OP] == TRUE))
	2154	PrintError(ERR_FORCE_TO_DP) ;
	2155	recordtype = PRINT_TWO_FOR_THREE ;
	2156	} else {
	2157	run.size = 4 ;
	2158	if (lea == FALSE) run.code[1] += (immediate == TRUE) ? 0x10 : 0x60 ;
	2159	run.code[2] = 0x9F ;
	2160	run.code[3] = (eval.operand >> 8) & 0xFF ;
	2161	run.code[4] = eval.operand & 0xFF ;
	2162	recordtype = PRINT_THREE_FOR_FOUR ;
	2163	}
	2164	break ;
	2165	}
	2166	}
	2167	}
	2168
	2169	/* Vérifie la présence d'un ']' pour le mode indirect */
	2170	if (indirect_mode == TRUE)
	2171	{
	2172	info.cycle.plus += (info.cycle.plus == -1) ? 4 : 3 ;
	2173	run.code[2] \|= 0x10 ;
	2174	if(*line != ']')
	2175	return PrintError(ERR_BAD_OPERAND) ;
	2176	line++ ;
	2177	}
	2178	return RecordLine(recordtype) ;
	2179	}
	2180
	2181	/*
	2182	* Assemblage opérande pour tout type
	2183	*/
	2184	int Ass_All (void)
	2185	{
	2186	return Ass_AllType (TRUE, FALSE) ;
	2187	}
	2188
	2189	/*
	2190	* Assemblage opérande pour tout type sauf immédiat
	2191	*/
	2192	int Ass_NotImmed (void)
	2193	{
	2194	return Ass_AllType (FALSE, FALSE) ;
	2195	}
	2196
	2197	/*
	2198	* Assemblage opérande pour LEAx
	2199	*/
	2200	int Ass_Lea (void)
	2201	{
	2202	return Ass_AllType (FALSE, TRUE) ;
	2203	}
	2204
	2205	/*-------------------------------------------------------------------
	2206	* Assemblage opérande pour immédiat
	2207	*/
	2208	int Ass_Immediate(void)
	2209	{
	2210	run.size = 2 ;
	2211	if (*line != '#')
	2212	return PrintError(ERR_BAD_OPERAND) ;
	2213	line++ ;
	2214	if (Eval()) return ERR_ERROR ;
	2215	if ((eval.operand < -256) \|\| (eval.operand > 255))
	2216	PrintError(ERR_OPERAND_OUT_OF_RANGE) ;
	2217	run.code[2] = eval.operand ;
	2218	return RecordLine(PRINT_TWO_FOR_TWO) ;
	2219	}
	2220
	2221	/*-------------------------------------------------------------------
	2222	* Assemblage opérande pour TFR/EXG
	2223	*/
	2224	int Ass_Transfer(void)
	2225	{
	2226	run.size = 2 ;
	2227	/* Premier registre */
	2228	if ((ScanLine() & ISREG) == 0)
	2229	return PrintError(ERR_BAD_OPERAND) ;
	2230	run.code[2] = run.regcode << 4 ;
	2231	/* Passe la virgule */
	2232	if (*line++ != ',')
	2233	return PrintError(ERR_BAD_OPERAND) ;
	2234	/* Deuxième registre */
	2235	if ((ScanLine() & ISREG) == 0)
	2236	return PrintError(ERR_BAD_OPERAND) ;
	2237	run.code[2] \|= run.regcode ;
	2238	/* Vérifie si erreur de registre
	2239	* Les bits 3 et 7 sont les bits de taille des registres
	2240	* Par masquage, on doit donc obtenir ou 0x88 ou 0x00 */
	2241	if (((run.code[2] & 0x88) != 0x00)
	2242	&& ((run.code[2] & 0x88) != 0x88))
	2243	PrintError(ERR_REGISTER_ERROR) ;
	2244	return RecordLine(PRINT_TWO_FOR_TWO) ;
	2245	}
	2246
	2247	/*-------------------------------------------------------------------
	2248	* Assemblage opérande pour PSHx/PULx
	2249	*/
	2250	int Ass_Stack(int exclude)
	2251	{
	2252	unsigned char StackTable[10] = {
	2253	0x06, /* D = 0x00 */
	2254	0x10, /* X = 0x01 */
	2255	0x20, /* Y = 0x02 */
	2256	0x40, /* U = 0x03 */
	2257	0x40, /* S = 0x04 */
	2258	0x80, /* PC = 0x05 */
	2259	0x02, /* A = 0x08 */
	2260	0x04, /* B = 0x09 */
	2261	0x01, /* CC = 0x0A */
	2262	0x08 /* DP = 0x0B */
	2263	} ;
	2264
	2265	int reg = 0;
	2266
	2267	info.cycle.plus = 0 ;
	2268	run.code[2] = 0 ;
	2269	run.size = 2 ;
	2270	do
	2271	{
	2272	/* Erreur si pas registre */
	2273	if ((ScanLine() & ISREG) == 0)
	2274	return PrintError(ERR_BAD_OPERAND) ;
	2275	/* Complète l'opérande */
	2276	reg = (run.regcode > REG_PC) ? run.regcode - 2 : run.regcode ;
	2277	if ((run.code[2] & StackTable[reg]) != 0)
	2278	PrintError(ERR_REGISTER_ERROR) ;
	2279	info.cycle.plus += (run.regcode > REG_PC) ? 1 : 2 ;
	2280	run.code[2] \|= StackTable[reg] ;
	2281	/* Exclut U pour PULU/PSHU et S pour PULS/PSHS */
	2282	if (run.regcode == exclude)
	2283	return PrintError(ERR_BAD_OPERAND) ;
	2284	} while (*(line++) == ',') ;
	2285	line--;
	2286	if (ScanLine() != END_CHAR)
	2287	return PrintError(ERR_BAD_OPERAND) ;
	2288	return RecordLine(PRINT_TWO_FOR_TWO) ;
	2289	}
	2290
	2291	/*
	2292	* Assemblage opérande pour PSHS/PULS
	2293	*/
	2294	int Ass_SStack(void)
	2295	{
	2296	return Ass_Stack(REG_S) ;
	2297	}
	2298
	2299	/*
	2300	* Assemblage opérande pour PSHS/PULS
	2301	*/
	2302	int Ass_UStack(void)
	2303	{
	2304	return Ass_Stack(REG_U) ;
	2305	}
	2306
	2307	/*-------------------------------------------------------------------
	2308	* Assemblage opérande pour inhérent
	2309	*/
	2310	int Ass_Inherent(void)
	2311	{
	2312	run.size = 1 ;
	2313	return RecordLine(PRINT_ONE_FOR_ONE) ;
	2314	}
	2315
	2316	/*-------------------------------------------------------------------
	2317	* Assemblage opérande pour branchements courts
	2318	*/
	2319	int Ass_ShortBr(void)
	2320	{
	2321	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2322	run.size = 2 ;
	2323	run.code[2] = 0xFE ;
	2324	eval.operand -= run.pc + run.size ;
	2325	if ((eval.operand < -128) \|\| (eval.operand > 127))
	2326	PrintError(ERR_BRANCH_OUT_OF_RANGE) ;
	2327	else
	2328	run.code[2] = eval.operand & 0xFF ;
	2329	return RecordLine(PRINT_TWO_FOR_TWO) ;
	2330	}
	2331
	2332	/*-------------------------------------------------------------------
	2333	* Assemblage opérande pour branchements longs
	2334	*/
	2335	int Ass_LongBr(void)
	2336	{
	2337	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2338	run.size = 3 ;
	2339	run.code[2] = 0xFF ;
	2340	run.code[3] = 0xFD ;
	2341	eval.operand -= run.pc + run.size + ((run.code[0] != 0) ? 1 : 0) ;
	2342	if (((eval.operand >= -128) && (eval.operand <= 127))
	2343	&& (run.opt[OPT_OP] == TRUE))
	2344	PrintError(ERR_8_BITS) ;
	2345	run.code[2] = (eval.operand >> 8) & 0xFF ;
	2346	run.code[3] = eval.operand & 0xFF ;
	2347	return RecordLine(PRINT_TWO_FOR_THREE) ;
	2348	}
	2349
	2350	/*-------------------------------------------------------------------
	2351	* Liste des instructions
	2352	*/
	2353	const struct {
	2354	char name[7] ; /* Nom de l'instruction */
	2355	unsigned char page ; /* Flag de page (0x00, 0x10 ou 0x11) */
	2356	unsigned char code ; /* Code de l'instruction */
	2357	int cycles ; /* Base de cycles */
	2358	int ifuppercase ; /* Pour création de fichiers Assembler
	2359	* TRUE = Opérande
	2360	* FALSE = Pas d'opérande */
	2361	int (prog)(void) ; / Programme de traitement */
	2362	} inst_table[] = {
	2363	{ "ABX" , 0x00, 0x3A, 3, FALSE, Ass_Inherent },
	2364	{ "ADCA" , 0x00, 0x89, 4, TRUE , Ass_All },
	2365	{ "ADCB" , 0x00, 0xC9, 4, TRUE , Ass_All },
	2366	{ "ADDA" , 0x00, 0x8B, 4, TRUE , Ass_All },
	2367	{ "ADDB" , 0x00, 0xCB, 4, TRUE , Ass_All },
	2368	{ "ADDD" , 0x00, 0xC3, 6, TRUE , Ass_All },
	2369	{ "ANDA" , 0x00, 0x84, 4, TRUE , Ass_All },
	2370	{ "ANDB" , 0x00, 0xC4, 4, TRUE , Ass_All },
	2371	{ "ANDCC", 0x00, 0x1C, 2, TRUE , Ass_Immediate },
	2372	{ "ASLA" , 0x00, 0x48, 2, FALSE, Ass_Inherent },
	2373	{ "ASLB" , 0x00, 0x58, 2, FALSE, Ass_Inherent },
	2374	{ "ASL" , 0x00, 0x08, 6, TRUE , Ass_NotImmed },
	2375	{ "ASRA" , 0x00, 0x47, 2, FALSE, Ass_Inherent },
	2376	{ "ASRB" , 0x00, 0x57, 2, FALSE, Ass_Inherent },
	2377	{ "ASR" , 0x00, 0x07, 6, TRUE , Ass_NotImmed },
	2378	{ "BITA" , 0x00, 0x85, 4, TRUE , Ass_All },
	2379	{ "BITB" , 0x00, 0xC5, 4, TRUE , Ass_All },
	2380	{ "BRA" , 0x00, 0x20, 3, TRUE , Ass_ShortBr },
	2381	{ "BRN" , 0x00, 0x21, 3, TRUE , Ass_ShortBr },
	2382	{ "BHI" , 0x00, 0x22, 3, TRUE , Ass_ShortBr },
	2383	{ "BLS" , 0x00, 0x23, 3, TRUE , Ass_ShortBr },
	2384	{ "BCC" , 0x00, 0x24, 3, TRUE , Ass_ShortBr },
	2385	{ "BHS" , 0x00, 0x24, 3, TRUE , Ass_ShortBr },
	2386	{ "BCS" , 0x00, 0x25, 3, TRUE , Ass_ShortBr },
	2387	{ "BLO" , 0x00, 0x25, 3, TRUE , Ass_ShortBr },
	2388	{ "BNE" , 0x00, 0x26, 3, TRUE , Ass_ShortBr },
	2389	{ "BEQ" , 0x00, 0x27, 3, TRUE , Ass_ShortBr },
	2390	{ "BVC" , 0x00, 0x28, 3, TRUE , Ass_ShortBr },
	2391	{ "BVS" , 0x00, 0x29, 3, TRUE , Ass_ShortBr },
	2392	{ "BPL" , 0x00, 0x2A, 3, TRUE , Ass_ShortBr },
	2393	{ "BMI" , 0x00, 0x2B, 3, TRUE , Ass_ShortBr },
	2394	{ "BGE" , 0x00, 0x2C, 3, TRUE , Ass_ShortBr },
	2395	{ "BLT" , 0x00, 0x2D, 3, TRUE , Ass_ShortBr },
	2396	{ "BGT" , 0x00, 0x2E, 3, TRUE , Ass_ShortBr },
	2397	{ "BLE" , 0x00, 0x2F, 3, TRUE , Ass_ShortBr },
	2398	{ "BSR" , 0x00, 0x8D, 7, TRUE , Ass_ShortBr },
	2399	{ "CLRA" , 0x00, 0x4F, 2, FALSE, Ass_Inherent },
	2400	{ "CLRB" , 0x00, 0x5F, 2, FALSE, Ass_Inherent },
	2401	{ "CLR" , 0x00, 0x0F, 6, TRUE , Ass_NotImmed },
	2402	{ "CMPA" , 0x00, 0x81, 4, TRUE , Ass_All },
	2403	{ "CMPB" , 0x00, 0xC1, 4, TRUE , Ass_All },
	2404	{ "CMPD" , 0x10, 0x83, 7, TRUE , Ass_All },
	2405	{ "CMPS" , 0x11, 0x8C, 7, TRUE , Ass_All },
	2406	{ "CMPU" , 0x11, 0x83, 7, TRUE , Ass_All },
	2407	{ "CMPX" , 0x00, 0x8C, 6, TRUE , Ass_All },
	2408	{ "CMPY" , 0x10, 0x8C, 7, TRUE , Ass_All },
	2409	{ "COMA" , 0x00, 0x43, 2, FALSE, Ass_Inherent },
	2410	{ "COMB" , 0x00, 0x53, 2, FALSE, Ass_Inherent },
	2411	{ "COM" , 0x00, 0x03, 6, TRUE , Ass_NotImmed },
	2412	{ "CWAI" , 0x00, 0x3C, 20, TRUE , Ass_Immediate },
	2413	{ "DAA" , 0x00, 0x19, 2, FALSE, Ass_Inherent },
	2414	{ "DECA" , 0x00, 0x4A, 2, FALSE, Ass_Inherent },
	2415	{ "DECB" , 0x00, 0x5A, 2, FALSE, Ass_Inherent },
	2416	{ "DEC" , 0x00, 0x0A, 6, TRUE , Ass_NotImmed },
	2417	{ "EORA" , 0x00, 0x88, 4, TRUE , Ass_All },
	2418	{ "EORB" , 0x00, 0xC8, 4, TRUE , Ass_All },
	2419	{ "EXG" , 0x00, 0x1E, 8, TRUE , Ass_Transfer },
	2420	{ "INCA" , 0x00, 0x4C, 2, FALSE, Ass_Inherent },
	2421	{ "INCB" , 0x00, 0x5C, 2, FALSE, Ass_Inherent },
	2422	{ "INC" , 0x00, 0x0C, 6, TRUE , Ass_NotImmed },
	2423	{ "JMP" , 0x00, 0x0E, 3, TRUE , Ass_NotImmed },
	2424	{ "JSR" , 0x00, 0x9D, 7, TRUE , Ass_All },
	2425	{ "LBRA" , 0x00, 0x16, 5, TRUE , Ass_LongBr },
	2426	{ "LBRN" , 0x10, 0x21, 5, TRUE , Ass_LongBr },
	2427	{ "LBHI" , 0x10, 0x22, 6, TRUE , Ass_LongBr },
	2428	{ "LBLS" , 0x10, 0x23, 6, TRUE , Ass_LongBr },
	2429	{ "LBCC" , 0x10, 0x24, 6, TRUE , Ass_LongBr },
	2430	{ "LBHS" , 0x10, 0x24, 6, TRUE , Ass_LongBr },
	2431	{ "LBCS" , 0x10, 0x25, 6, TRUE , Ass_LongBr },
	2432	{ "LBLO" , 0x10, 0x25, 6, TRUE , Ass_LongBr },
	2433	{ "LBNE" , 0x10, 0x26, 6, TRUE , Ass_LongBr },
	2434	{ "LBEQ" , 0x10, 0x27, 6, TRUE , Ass_LongBr },
	2435	{ "LBVC" , 0x10, 0x28, 6, TRUE , Ass_LongBr },
	2436	{ "LBVS" , 0x10, 0x29, 6, TRUE , Ass_LongBr },
	2437	{ "LBPL" , 0x10, 0x2A, 6, TRUE , Ass_LongBr },
	2438	{ "LBMI" , 0x10, 0x2B, 6, TRUE , Ass_LongBr },
	2439	{ "LBGE" , 0x10, 0x2C, 6, TRUE , Ass_LongBr },
	2440	{ "LBLT" , 0x10, 0x2D, 6, TRUE , Ass_LongBr },
	2441	{ "LBGT" , 0x10, 0x2E, 6, TRUE , Ass_LongBr },
	2442	{ "LBLE" , 0x10, 0x2F, 6, TRUE , Ass_LongBr },
	2443	{ "LBSR" , 0x00, 0x17, 9, TRUE , Ass_LongBr },
	2444	{ "LDA" , 0x00, 0x86, 4, TRUE , Ass_All },
	2445	{ "LDB" , 0x00, 0xC6, 4, TRUE , Ass_All },
	2446	{ "LDD" , 0x00, 0xCC, 5, TRUE , Ass_All },
	2447	{ "LDS" , 0x10, 0xCE, 6, TRUE , Ass_All },
	2448	{ "LDU" , 0x00, 0xCE, 5, TRUE , Ass_All },
	2449	{ "LDX" , 0x00, 0x8E, 5, TRUE , Ass_All },
	2450	{ "LDY" , 0x10, 0x8E, 6, TRUE , Ass_All },
	2451	{ "LEAS" , 0x00, 0x32, 4, TRUE , Ass_Lea },
	2452	{ "LEAU" , 0x00, 0x33, 4, TRUE , Ass_Lea },
	2453	{ "LEAX" , 0x00, 0x30, 4, TRUE , Ass_Lea },
	2454	{ "LEAY" , 0x00, 0x31, 4, TRUE , Ass_Lea },
	2455	{ "LSLA" , 0x00, 0x48, 2, FALSE, Ass_Inherent },
	2456	{ "LSLB" , 0x00, 0x58, 2, FALSE, Ass_Inherent },
	2457	{ "LSL" , 0x00, 0x08, 6, TRUE , Ass_NotImmed },
	2458	{ "LSRA" , 0x00, 0x44, 2, FALSE, Ass_Inherent },
	2459	{ "LSRB" , 0x00, 0x54, 2, FALSE, Ass_Inherent },
	2460	{ "LSR" , 0x00, 0x04, 6, TRUE , Ass_NotImmed },
	2461	{ "MUL" , 0x00, 0x3D, 11, FALSE, Ass_Inherent },
	2462	{ "NEGA" , 0x00, 0x40, 2, FALSE, Ass_Inherent },
	2463	{ "NEGB" , 0x00, 0x50, 2, FALSE, Ass_Inherent },
	2464	{ "NEG" , 0x00, 0x00, 6, TRUE , Ass_NotImmed },
	2465	{ "NOP" , 0x00, 0x12, 2, FALSE, Ass_Inherent },
	2466	{ "ORA" , 0x00, 0x8A, 4, TRUE , Ass_All },
	2467	{ "ORB" , 0x00, 0xCA, 4, TRUE , Ass_All },
	2468	{ "ORCC" , 0x00, 0x1A, 2, TRUE , Ass_Immediate },
	2469	{ "PSHS" , 0x00, 0x34, 5, TRUE , Ass_SStack },
	2470	{ "PSHU" , 0x00, 0x36, 5, TRUE , Ass_UStack },
	2471	{ "PULS" , 0x00, 0x35, 5, TRUE , Ass_SStack },
	2472	{ "PULU" , 0x00, 0x37, 5, TRUE , Ass_UStack },
	2473	{ "ROLA" , 0x00, 0x49, 2, FALSE, Ass_Inherent },
	2474	{ "ROLB" , 0x00, 0x59, 2, FALSE, Ass_Inherent },
	2475	{ "ROL" , 0x00, 0x09, 6, TRUE , Ass_NotImmed },
	2476	{ "RORA" , 0x00, 0x46, 2, FALSE, Ass_Inherent },
	2477	{ "RORB" , 0x00, 0x56, 2, FALSE, Ass_Inherent },
	2478	{ "ROR" , 0x00, 0x06, 6, TRUE , Ass_NotImmed },
	2479	{ "RTI" , 0x00, 0x3B, 15, FALSE, Ass_Inherent },
	2480	{ "RTS" , 0x00, 0x39, 5, FALSE, Ass_Inherent },
	2481	{ "SBCA" , 0x00, 0x82, 4, TRUE , Ass_All },
	2482	{ "SBCB" , 0x00, 0xC2, 4, TRUE , Ass_All },
	2483	{ "SEX" , 0x00, 0x1D, 2, FALSE, Ass_Inherent },
	2484	{ "STA" , 0x00, 0x97, 4, TRUE , Ass_All },
	2485	{ "STB" , 0x00, 0xD7, 4, TRUE , Ass_All },
	2486	{ "STD" , 0x00, 0xDD, 5, TRUE , Ass_All },
	2487	{ "STS" , 0x10, 0xDF, 6, TRUE , Ass_All },
	2488	{ "STU" , 0x00, 0xDF, 5, TRUE , Ass_All },
	2489	{ "STX" , 0x00, 0x9F, 5, TRUE , Ass_All },
	2490	{ "STY" , 0x10, 0x9F, 6, TRUE , Ass_All },
	2491	{ "SUBA" , 0x00, 0x80, 4, TRUE , Ass_All },
	2492	{ "SUBB" , 0x00, 0xC0, 4, TRUE , Ass_All },
	2493	{ "SUBD" , 0x00, 0x83, 6, TRUE , Ass_All },
	2494	{ "SWI" , 0x00, 0x3F, 19, FALSE, Ass_Inherent },
	2495	{ "SWI2" , 0x10, 0x3F, 20, FALSE, Ass_Inherent },
	2496	{ "SWI3" , 0x11, 0x3F, 20, FALSE, Ass_Inherent },
	2497	{ "SYNC" , 0x00, 0x13, 4, FALSE, Ass_Inherent },
	2498	{ "TFR" , 0x00, 0x1F, 6, TRUE , Ass_Transfer },
	2499	{ "TSTA" , 0x00, 0x4D, 2, FALSE, Ass_Inherent },
	2500	{ "TSTB" , 0x00, 0x5D, 2, FALSE, Ass_Inherent },
	2501	{ "TST" , 0x00, 0x0D, 6, TRUE , Ass_NotImmed }
	2502	};
	2503	#define ITSIZE (int)sizeof(inst_table)/(int)sizeof(inst_table[0])
	2504
	2505
	2506	/***********************************************************************
	2507	*
	2508	* Assemblage des directives
	2509	*
	2510	***********************************************************************/
	2511
	2512	/*
	2513	* Récupération d'un descripteur de fichier
	2514	*/
	2515	struct {
	2516	int drive ; /* Numéro du lecteur */
	2517	char name[14] ; /* Nom du fichier : xxxxxxxx.xxx */
	2518	} desc ;
	2519
	2520	int GetDescriptor(char *suffix)
	2521	{
	2522	int i ;
	2523
	2524	if ((*line != '\0')
	2525	&& (*(line+1) == ':'))
	2526	{
	2527	if ((line <= '0') && (line > '4'))
	2528	return PrintError(ERR_BAD_FILE_NAME) ;
	2529	desc.drive = *line - '0' ;
	2530	line += 2 ;
	2531	}
	2532
	2533	desc.name[0] = '\0' ;
	2534	for(i=0;i<9;i++)
	2535	{
	2536	if ((*line == 0x20)
	2537	\|\| (*line == 0x00)
	2538	\|\| (*line == CHAR127)
	2539	\|\| (*line == '.'))
	2540	break ;
	2541	if ((*line == '(')
	2542	\|\| (*line == ')')
	2543	\|\| (*line == ':')
	2544	\|\| ((*line & 0xFF) > 0x7F))
	2545	return PrintError(ERR_BAD_FILE_NAME) ;
	2546	strncat(desc.name,line++,1) ;
	2547	}
	2548
	2549	if ((i > 8) \|\| (i == 0))
	2550	return PrintError(ERR_BAD_FILE_NAME) ;
	2551
	2552	if (*line == '.')
	2553	{
	2554	strcat(desc.name,".") ;
	2555	line++ ;
	2556	for(i=0;i<4;i++)
	2557	{
	2558	if ((*line == 0x20)
	2559	\|\| (*line == CHAR127)
	2560	\|\| (*line == 0x00))
	2561	break ;
	2562	if ((*line == '(')
	2563	\|\| (*line == ')')
	2564	\|\| (*line == ':')
	2565	\|\| (*line == '.')
	2566	\|\| ((*line & 0xFF) > 0x7F))
	2567	return PrintError(ERR_BAD_FILE_NAME) ;
	2568	strncat(desc.name,line++,1) ;
	2569	}
	2570	if (i > 3)
	2571	return PrintError(ERR_BAD_FILE_NAME) ;
	2572	}
	2573	else
	2574	{
	2575	strcat(desc.name,".") ;
	2576	strcat(desc.name,suffix) ;
	2577	}
	2578
	2579	return NO_ERROR ;
	2580	}
	2581
	2582	/*-------------------------------------------------------------------
	2583	* Assemblage des directives Fill
	2584	*/
	2585
	2586	enum{
	2587	FCB_TYPE,
	2588	FCC_TYPE,
	2589	FCN_TYPE,
	2590	FCS_TYPE,
	2591	FDB_TYPE
	2592	} ;
	2593
	2594	/*
	2595	* Enregistre la liste des codes
	2596	*/
	2597	int RecordFC(int flag, int type)
	2598	{
	2599	int i ;
	2600	if (run.size != 0)
	2601	{
	2602	RecordLine(flag) ;
	2603	flag = (type == FDB_TYPE) ? PRINT_WORDS_ONLY : PRINT_BYTES_ONLY ;
	2604	for(i=0;i<run.size;i++)
	2605	SaveBinChar(run.code[i+1]) ;
	2606	run.size = 0 ;
	2607	}
	2608	return flag ;
	2609	}
	2610
	2611	/*
	2612	* Enregistre la liste des codes si buffer plein
	2613	*/
	2614	int RecordFCIf(unsigned char c, int flag, int type)
	2615	{
	2616	if(run.size == 4)
	2617	flag = RecordFC(flag,type) ;
	2618	run.code[++run.size] = c ;
	2619	return flag ;
	2620	}
	2621
	2622	int Ass_All_FC(int type)
	2623	{
	2624	int i ;
	2625	int flag = (type == FDB_TYPE) ? PRINT_WORDS : PRINT_BYTES ;
	2626	int flagexit = FALSE ;
	2627	unsigned char charend = '\0' ;
	2628
	2629	char asciitable[][2] = {
	2630	"Kc", /* c cédille */
	2631	"Ba", /* a accent aigu */
	2632	"Ca", /* a accent circ */
	2633	"Ha", /* a tréma */
	2634	"Aa", /* a accent grave */
	2635	"Be", /* e accent aigu */
	2636	"Ce", /* e accent circ */
	2637	"He", /* e tréma */
	2638	"Ae", /* e accent grave */
	2639	"Ci", /* i accent circ */
	2640	"Hi", /* i tréma */
	2641	"Co", /* o accent circ */
	2642	"Ho", /* o tréma */
	2643	"Cu", /* u accent circ */
	2644	"Hu", /* u tréma */
	2645	"Au" /* u accent grave */
	2646	} ;
	2647
	2648	run.size = 0 ;
	2649
	2650	if ((type != FCB_TYPE) && (type != FDB_TYPE))
	2651	{
	2652	if (*line == '\0')
	2653	return PrintError(ERR_MISSING_INFORMATION) ;
	2654	else
	2655	charend = *(line++) ;
	2656	}
	2657
	2658	do
	2659	{
	2660	switch(type)
	2661	{
	2662	case FCB_TYPE :
	2663	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2664	if ((eval.operand < -256 ) \|\| (eval.operand > 255))
	2665	PrintError(ERR_OPERAND_OUT_OF_RANGE) ;
	2666	flag = RecordFCIf(eval.operand & 0xFF, flag, type) ;
	2667	if (*line == ',') line++ ; else flagexit = TRUE ;
	2668	break ;
	2669	case FDB_TYPE :
	2670	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2671	flag = RecordFCIf((eval.operand >> 8) & 0xFF, flag, type) ;
	2672	flag = RecordFCIf(eval.operand & 0xFF, flag, type) ;
	2673	if (*line == ',') line++ ; else flagexit = TRUE ;
	2674	break ;
	2675	default :
	2676	if (*line == '\0')
	2677	return PrintError(ERR_MISSING_INFORMATION) ;
	2678	else
	2679	if (*line == charend)
	2680	{
	2681	flagexit = TRUE ;
	2682	if ((type == FCN_TYPE)
	2683	&& (run.size > 0))
	2684	run.code[run.size] \|= 0x80 ;
	2685	line++ ;
	2686	}
	2687	else
	2688	if ((unsigned char)*line > 0x7F)
	2689	{
	2690	if (scan.soft == SOFT_ASSEMBLER)
	2691	return PrintError(ERR_BAD_OPERAND) ;
	2692	i = 0 ;
	2693	while (*line != acc_table[i]) i++ ;
	2694	flag = RecordFCIf(0x16, flag, type) ;
	2695	flag = RecordFCIf(asciitable[i][0], flag, type) ;
	2696	flag = RecordFCIf(asciitable[i][1], flag, type) ;
	2697	line++ ;
	2698	}
	2699	else
	2700	if (*line >= 0x20)
	2701	{
	2702	if (*line == CHAR127)
	2703	flag = RecordFCIf(' ', flag, type) ;
	2704	else
	2705	flag = RecordFCIf(*line, flag, type) ;
	2706	line++ ;
	2707	}
	2708	break ;
	2709	}
	2710	} while(flagexit == FALSE) ;
	2711
	2712	if (type == FCS_TYPE) {
	2713	flag = RecordFCIf(0x00, flag, type) ; }
	2714
	2715	if (run.size != 0)
	2716	RecordFC(flag, type) ;
	2717
	2718	return NO_ERROR ;
	2719	}
	2720
	2721
	2722	int Ass_FCB(void)
	2723	{
	2724	return Ass_All_FC(FCB_TYPE) ;
	2725	}
	2726
	2727	int Ass_FCC(void)
	2728	{
	2729	return Ass_All_FC(FCC_TYPE) ;
	2730	}
	2731
	2732	int Ass_FCS(void)
	2733	{
	2734	return Ass_All_FC(FCS_TYPE) ;
	2735	}
	2736
	2737	int Ass_FCN(void)
	2738	{
	2739	return Ass_All_FC(FCN_TYPE) ;
	2740	}
	2741
	2742	int Ass_FDB(void)
	2743	{
	2744	return Ass_All_FC(FDB_TYPE) ;
	2745	}
	2746
	2747	/*-------------------------------------------------------------------
	2748	* Assemblage des réservations mémoire
	2749	*/
	2750
	2751	int Ass_PrintWithPcr(unsigned short pcr2)
	2752	{
	2753	unsigned short pcr1 ;
	2754	pcr1 = run.pc ;
	2755	run.pc = pcr2 ;
	2756	RecordLine(PRINT_PC) ;
	2757	run.pc = pcr1 ;
	2758	return NO_ERROR ;
	2759	}
	2760
	2761	int Ass_RMx(int size)
	2762	{
	2763	int i ;
	2764	int count ;
	2765	unsigned short pcr = run.pc ;
	2766
	2767	run.size = 0 ;
	2768	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2769	if ((count = eval.operand) < 0)
	2770	return PrintError(ERR_BAD_OPERAND) ;
	2771	if(*line != ',')
	2772	run.pc += count * size ;
	2773	else
	2774	{
	2775	if (scan.soft == SOFT_ASSEMBLER)
	2776	return PrintError(ERR_BAD_OPERAND) ;
	2777	line++ ;
	2778	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2779	if ((size == 1)
	2780	&& ((eval.operand < -256) \|\| (eval.operand > 255)))
	2781	return PrintError(ERR_BAD_OPERAND) ;
	2782	for(i=0;i<count;i++)
	2783	{
	2784	if (size == 2)
	2785	SaveBinChar((eval.operand >> 8) & 0xFF) ;
	2786	SaveBinChar(eval.operand & 0xFF) ;
	2787	}
	2788	}
	2789	return Ass_PrintWithPcr(pcr) ;
	2790	}
	2791
	2792	int Ass_RMB(void)
	2793	{
	2794	return Ass_RMx(1) ;
	2795	}
	2796
	2797	int Ass_RMD(void)
	2798	{
	2799	return Ass_RMx(2) ;
	2800	}
	2801
	2802	/*-------------------------------------------------------------------
	2803	* Assemblage des directives MO
	2804	*/
	2805
	2806	int Ass_Special_MO(void)
	2807	{
	2808	if ((scan.soft == SOFT_ASSEMBLER)
	2809	&& (scan.computer != MO_COMPUTER))
	2810	return PrintError(ERR_BAD_OPCODE) ;
	2811	return NO_ERROR ;
	2812	}
	2813
	2814	int Ass_CALL_And_GOTO(unsigned char jump)
	2815	{
	2816	if (Ass_Special_MO() != NO_ERROR) return ERR_ERROR ;
	2817	run.size = 2 ;
	2818	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2819	if((eval.operand < 0) \|\| (eval.operand > 255))
	2820	return PrintError(ERR_BAD_OPERAND) ;
	2821	run.code[0] = 0x00 ;
	2822	run.code[1] = 0x3F ;
	2823	run.code[2] = (eval.operand & 0xFF) \| jump ;
	2824	return RecordLine(PRINT_TWO_FOR_TWO) ;
	2825	}
	2826
	2827	int Ass_CALL(void)
	2828	{
	2829	return Ass_CALL_And_GOTO(0x00) ;
	2830	}
	2831
	2832	int Ass_GOTO(void)
	2833	{
	2834	return Ass_CALL_And_GOTO(0x80) ;
	2835	}
	2836
	2837	int Ass_STOP(void)
	2838	{
	2839	if (Ass_Special_MO() != NO_ERROR) return ERR_ERROR ;
	2840	run.size = 3 ;
	2841	run.code[0] = 0x00 ;
	2842	run.code[1] = 0xBD ;
	2843	run.code[2] = 0xB0 ;
	2844	run.code[3] = 0x00 ;
	2845	return RecordLine(PRINT_TWO_FOR_THREE) ;
	2846	}
	2847
	2848	/*-------------------------------------------------------------------
	2849	* Assemblage des déclarations
	2850	*/
	2851
	2852	int Ass_SET_And_EQU(int type)
	2853	{
	2854	if (Eval() != NO_ERROR) return ERR_ERROR ;
	2855	if (DoSymbol(labelname,eval.operand,type) != NO_ERROR)
	2856	return ERR_ERROR ;
	2857	return RecordLine(PRINT_LIKE_END) ;
	2858	}
	2859
	2860	int Ass_SET(void)
	2861	{
	2862	return Ass_SET_And_EQU(SET_VALUE) ;
	2863	}
	2864
	2865	int Ass_EQU(void)
	2866	{
	2867	return Ass_SET_And_EQU(EQU_VALUE) ;
	2868	}
	2869
	2870	/*-------------------------------------------------------------------
	2871	* Assemblage des includes
	2872	*/
	2873
	2874	struct SRCLIST {
	2875	struct SRCLIST next ; / Pointeur sur section suivante */
	2876	unsigned char drive ; /* Numéro de lecteur */
	2877	char name[13] ; /* Nom du fichier xxxxxxxx.xxx */
	2878	int line ; /* Numéro de ligne */
	2879	int asm_size ; /* Taille ASM compressé */
	2880	char start ; / Pointeur sur début du source */
	2881	char end ; / Pointeur sur fin du source */
	2882	} ;
	2883
	2884	struct SRCLIST *first_source ;
	2885	struct SRCLIST *current_source ;
	2886
	2887	/*
	2888	* Initialise le chaînage des includes
	2889	*/
	2890	void InitIncludChain(void)
	2891	{
	2892	first_includ = malloc(sizeof(struct INCLIST)) ;
	2893	first_includ->prev = NULL ;
	2894	first_includ->line = first_source->line ;
	2895	first_includ->count = 0 ;
	2896	first_includ->drive = first_source->drive ;
	2897	first_includ->name[0] = '\0' ;
	2898	strcat(first_includ->name,first_source->name) ;
	2899	first_includ->start = first_source->start ;
	2900	first_includ->end = first_source->end ;
	2901	}
	2902
	2903	/*
	2904	* Libère la mémoire pour le chaînage des includes
	2905	*/
	2906	void FreeIncludChain(void)
	2907	{
	2908	struct INCLIST *last_includ ;
	2909	while((last_includ = first_includ))
	2910	{
	2911	first_includ = first_includ->prev ;
	2912	free(last_includ) ;
	2913	}
	2914	}
	2915
	2916	/*
	2917	* Engage une séquence d'include
	2918	*/
	2919	int Ass_Start_INC(char *suffix)
	2920	{
	2921	if (((run.locked & MACRO_LOCK) \|\| (macro.level))
	2922	&& (scan.soft == SOFT_MACROASSEMBLER))
	2923	return PrintError(ERR_ILLEGAL_INCLUDE) ;
	2924	if(GetDescriptor(suffix) != NO_ERROR) return ERR_ERROR ;
	2925	return NO_ERROR ;
	2926	}
	2927
	2928
	2929	/*
	2930	* Assemble les INCLUD
	2931	*/
	2932	int Ass_INCLUD(void)
	2933	{
	2934	struct INCLIST *prev_includ = NULL ;
	2935
	2936	if (Ass_Start_INC("ASM") != NO_ERROR)
	2937	return ERR_ERROR ;
	2938	if (run.pass > MACROPASS)
	2939	{
	2940	/* Recherche l'include dans la liste des sources */
	2941	current_source = first_source ;
	2942	while((current_source != NULL)
	2943	&& (strcmp(current_source->name,desc.name)))
	2944	current_source = current_source->next ;
	2945
	2946	/* Erreur si INCLUD introuvable */
	2947	if (current_source == NULL)
	2948	return PrintError(ERR_FILE_NOT_FOUND) ;
	2949
	2950	/* Met l'includ courant à jour */
	2951	first_includ->start = source ;
	2952	first_includ->line = run.line ;
	2953	/* Crée le nouvel includ */
	2954	prev_includ = first_includ ;
	2955	first_includ = malloc(sizeof(struct INCLIST)) ;
	2956	first_includ->prev = prev_includ ;
	2957	first_includ->drive = current_source->drive ;
	2958	first_includ->name[0] = '\0' ;
	2959	strcat(first_includ->name, current_source->name) ;
	2960	first_includ->line = current_source->line ;
	2961	first_includ->start = current_source->start ;
	2962	first_includ->end = current_source->end ;
	2963	first_includ->count = prev_includ->count + 1 ;
	2964	source = first_includ->start ;
	2965	run.line = first_includ->line ;
	2966	RecordLine(PRINT_NO_CODE) ;
	2967	}
	2968	return NO_ERROR ;
	2969	}
	2970
	2971	/*
	2972	* Erreur 'Bad File Format' pour les INCBIN
	2973	*/
	2974	int Ass_BadFileFormat(FILE *fp_file)
	2975	{
	2976	fclose(fp_file) ;
	2977	return PrintError(ERR_BAD_FILE_FORMAT) ;
	2978	}
	2979
	2980	/*
	2981	* Assemble les INCBIN
	2982	*/
	2983	int Ass_INCBIN(void)
	2984	{
	2985	FILE *fp_file;
	2986	int flag = 0 ;
	2987	int size = 0 ;
	2988	int i ;
	2989	unsigned short pcr = run.pc ;
	2990
	2991	if (Ass_Start_INC("BIN") != NO_ERROR)
	2992	return ERR_ERROR ;
	2993	printf("fichier = %s\n",desc.name) ;
	2994	if ((fp_file = fopen(desc.name,"rb")) == NULL)
	2995	return PrintError(ERR_FILE_NOT_FOUND) ;
	2996
	2997	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	2998	printf("flag = %08x\n",flag) ;
	2999	flag = fgetc(fp_file) ;
	3000	printf("flag = %08x\n",flag) ;
	3001	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3002	while (flag == 0x00)
	3003	{
	3004	size = fgetc(fp_file) << 8 ;
	3005	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3006	size \|= fgetc(fp_file) ;
	3007	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3008	fgetc(fp_file) ;
	3009	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3010	fgetc(fp_file) ;
	3011	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3012	for(i=0;i<size;i++)
	3013	{
	3014	SaveBinChar(fgetc(fp_file)) ;
	3015	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3016	}
	3017	flag = fgetc(fp_file) ;
	3018	if (feof(fp_file)) return Ass_BadFileFormat(fp_file) ;
	3019	}
	3020	if (flag != 0xFF)
	3021	return Ass_BadFileFormat(fp_file) ;
	3022	if ((fgetc(fp_file) != 0x00)
	3023	\|\| (feof(fp_file)))
	3024	return Ass_BadFileFormat(fp_file) ;
	3025	if ((fgetc(fp_file) != 0x00)
	3026	\|\| (feof(fp_file)))
	3027	return Ass_BadFileFormat(fp_file) ;
	3028	fgetc(fp_file) ;
	3029	if (feof(fp_file))
	3030	return Ass_BadFileFormat(fp_file) ;
	3031	fclose(fp_file) ;
	3032
	3033	return Ass_PrintWithPcr(pcr) ;
	3034	}
	3035
	3036	/*
	3037	* Assemble les INCDAT
	3038	*/
	3039	int Ass_INCDAT(void)
	3040	{
	3041	FILE *fp_file ;
	3042	unsigned short pcr = run.pc ;
	3043
	3044	if (Ass_Start_INC("") != NO_ERROR)
	3045	return ERR_ERROR ;
	3046	if ((fp_file = fopen(desc.name,"rb")) == NULL)
	3047	return PrintError(ERR_FILE_NOT_FOUND) ;
	3048	while (!feof(fp_file))
	3049	SaveBinChar(fgetc(fp_file)) ;
	3050	fclose(fp_file) ;
	3051	return Ass_PrintWithPcr(pcr) ;
	3052	}
	3053
	3054	/*-------------------------------------------------------------------
	3055	* Assemblage d'affichage
	3056	*/
	3057
	3058	int Ass_ECHO(void)
	3059	{
	3060	char c ;
	3061	int i ;
	3062	char operand[18] ;
	3063	char echoline[LINE_MAX_SIZE+2] ;
	3064
	3065	if ((run.pass == PASS2)
	3066	&& (run.opt[OPT_WL] == FALSE))
	3067	{
	3068	echoline[0] = '\0' ;
	3069	while(*line != 0)
	3070	{
	3071	operand[0] = '\0' ;
	3072	switch (c = *(line++))
	3073	{
	3074	case '%':
	3075	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3076	strcat(operand,"%") ;
	3077	i = 0x8000 ;
	3078	while(((eval.operand & i) == 0) && (i != 1))
	3079	i >>= 1 ;
	3080	while(i != 0) {
	3081	if (eval.operand & i) strcat(operand,"1") ;
	3082	else strcat(operand,"0") ;
	3083	i >>= 1 ; }
	3084	break ;
	3085	case '@':
	3086	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3087	sprintf(operand,"@%o",eval.operand & 0xFFFF) ;
	3088	break ;
	3089	case '&':
	3090	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3091	sprintf(operand,"%d",eval.operand & 0xFFFF) ;
	3092	break ;
	3093	case '$':
	3094	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3095	sprintf(operand,"$%04X",eval.operand & 0xFFFF) ;
	3096	break ;
	3097	default :
	3098	strncat(echoline,&c,1) ;
	3099	break ;
	3100	}
	3101	strcat(echoline,operand) ;
	3102	}
	3103	printf("%s\n",echoline) ;
	3104	}
	3105	return RecordLine(PRINT_NO_CODE) ;
	3106	}
	3107
	3108	int Ass_PRINT(void)
	3109	{
	3110	if ((run.pass == PASS1)
	3111	&& (run.opt[OPT_WL] == FALSE))
	3112	printf("%s\n",line) ;
	3113	return RecordLine(PRINT_NO_CODE) ;
	3114	}
	3115
	3116	/*-------------------------------------------------------------------
	3117	* Assemblage de mise en page
	3118	*/
	3119
	3120	int Ass_TITLE(void)
	3121	{
	3122	return RecordLine(PRINT_NO_CODE) ;
	3123	}
	3124
	3125	int Ass_PAGE(void)
	3126	{
	3127	if (*line != '\0')
	3128	return PrintError(ERR_ILLEGAL_OPERAND) ;
	3129	return RecordLine(PRINT_NO_CODE) ;
	3130	}
	3131
	3132	/*-------------------------------------------------------------------
	3133	* Assemblage conditionnel
	3134	*/
	3135
	3136	enum {
	3137	IF_IFNE,
	3138	IF_IFEQ,
	3139	IF_IFGT,
	3140	IF_IFLT,
	3141	IF_IFGE,
	3142	IF_IFLE
	3143	} ;
	3144
	3145	int Ass_All_IF(int condition)
	3146	{
	3147	int result = FALSE ;
	3148
	3149	if (run.locked & (COMMENT_LOCK \| MACRO_LOCK))
	3150	return RecordLine(PRINT_NO_CODE) ;
	3151	if ((ifc.count == 16)
	3152	&& (scan.soft == SOFT_MACROASSEMBLER))
	3153	return PrintError(ERR_IF_OUT_OF_RANGE) ;
	3154	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3155	switch(condition)
	3156	{
	3157	case IF_IFNE : result = (eval.operand != 0) ; break ;
	3158	case IF_IFEQ : result = (eval.operand == 0) ; break ;
	3159	case IF_IFGT : result = (eval.operand > 0) ; break ;
	3160	case IF_IFLT : result = (eval.operand < 0) ; break ;
	3161	case IF_IFGE : result = (eval.operand >= 0) ; break ;
	3162	case IF_IFLE : result = (eval.operand <= 0) ; break ;
	3163	}
	3164
	3165	ifc.count++ ;
	3166	if ((ifc.buf[ifc.count - 1] == IF_TRUE)
	3167	\|\| (ifc.buf[ifc.count - 1] == IF_FALSE_ELSE))
	3168	ifc.buf[ifc.count] = (result == TRUE) ? IF_TRUE : IF_FALSE ;
	3169	else
	3170	ifc.buf[ifc.count] = IF_STOP ;
	3171
	3172	run.locked &= ~IF_LOCK ;
	3173	if (ifc.buf[ifc.count] != IF_TRUE) run.locked \|= IF_LOCK ;
	3174
	3175	return RecordLine(PRINT_NO_CODE) ;
	3176	}
	3177
	3178	int Ass_IF(void)
	3179	{
	3180	return Ass_All_IF(IF_IFNE) ;
	3181	}
	3182
	3183	int Ass_IFNE(void)
	3184	{
	3185	return Ass_All_IF(IF_IFNE) ;
	3186	}
	3187
	3188	int Ass_IFEQ(void)
	3189	{
	3190	return Ass_All_IF(IF_IFEQ) ;
	3191	}
	3192
	3193	int Ass_IFGT(void)
	3194	{
	3195	return Ass_All_IF(IF_IFGT) ;
	3196	}
	3197
	3198	int Ass_IFLT(void)
	3199	{
	3200	return Ass_All_IF(IF_IFLT) ;
	3201	}
	3202
	3203	int Ass_IFGE(void)
	3204	{
	3205	return Ass_All_IF(IF_IFGE) ;
	3206	}
	3207
	3208	int Ass_IFLE(void)
	3209	{
	3210	return Ass_All_IF(IF_IFLE) ;
	3211	}
	3212
	3213	int Ass_ELSE(void)
	3214	{
	3215	if (run.locked & (COMMENT_LOCK \| MACRO_LOCK))
	3216	return RecordLine(PRINT_NO_CODE) ;
	3217
	3218	if (ifc.count == 0)
	3219	return PrintError(ERR_MISSING_IF) ;
	3220
	3221	switch(ifc.buf[ifc.count])
	3222	{
	3223	case IF_TRUE_ELSE :
	3224	case IF_FALSE_ELSE :
	3225	return PrintError(ERR_BAD_ELSE) ;
	3226	break ;
	3227	case IF_STOP :
	3228	break ;
	3229	default :
	3230	ifc.buf[ifc.count] = (ifc.buf[ifc.count] == IF_TRUE) ? IF_TRUE_ELSE : IF_FALSE_ELSE ;
	3231	break ;
	3232	}
	3233	run.locked &= ~IF_LOCK ;
	3234	if (ifc.buf[ifc.count] != IF_FALSE_ELSE) run.locked \|= IF_LOCK ;
	3235
	3236	return RecordLine(PRINT_NO_CODE) ;
	3237	}
	3238
	3239	int Ass_ENDC(void)
	3240	{
	3241	if (run.locked & (COMMENT_LOCK \| MACRO_LOCK))
	3242	return RecordLine(PRINT_NO_CODE) ;
	3243
	3244	if (ifc.count == 0)
	3245	return PrintError(ERR_MISSING_IF) ;
	3246
	3247	ifc.count-- ;
	3248	run.locked &= ~IF_LOCK ;
	3249	if ((ifc.buf[ifc.count] != IF_FALSE_ELSE)
	3250	&& (ifc.buf[ifc.count] != IF_TRUE)) run.locked \|= IF_LOCK ;
	3251
	3252	return RecordLine(PRINT_NO_CODE) ;
	3253	}
	3254
	3255	/*-------------------------------------------------------------------
	3256	* Assemblage des macros
	3257	*/
	3258
	3259	struct MACROLIST {
	3260	struct MACROLIST next ; / Pointeur sur section suivante */
	3261	int count ; /* Identificateur de macro */
	3262	int line ; /* Numéro de ligne */
	3263	char arg[10] ; / Liste des arguments */
	3264	char start ; / Pointeur sur début de macro */
	3265	char end ; / Pointeur sur fin de macro */
	3266	} ;
	3267
	3268	struct MACROLIST *first_macro ;
	3269	struct MACROLIST *current_macro ;
	3270	extern int CheckIfReservedName(void) ;
	3271
	3272	struct MACROARGLIST {
	3273	struct MACROARGLIST prev ; / Pointeur sur section précedente */
	3274	int line ; /* Numéro de ligne */
	3275	char ptr ; / Ptr sur macro */
	3276	char arg[10] ; / Liste des arguments de macro */
	3277	} ;
	3278
	3279	struct MACROARGLIST *current_macroarg ;
	3280
	3281	/*
	3282	* Initialise le chaînage des macros
	3283	*/
	3284	void InitMacroChain(void)
	3285	{
	3286	first_macro = malloc(sizeof(struct MACROLIST)) ;
	3287	first_macro->next = NULL ;
	3288	first_macro->line = 0 ;
	3289	first_macro->start = NULL ;
	3290	first_macro->end = NULL ;
	3291	current_macro = first_macro ;
	3292	}
	3293
	3294	/*
	3295	* Libère la mémoire pour le chaînage des macros
	3296	*/
	3297	void FreeMacroChain(void)
	3298	{
	3299	while((current_macro = first_macro))
	3300	{
	3301	first_macro = first_macro->next ;
	3302	free(current_macro) ;
	3303	}
	3304	}
	3305
	3306
	3307	int Ass_MACRO(void)
	3308	{
	3309	if (run.locked & (COMMENT_LOCK + IF_LOCK))
	3310	return RecordLine(PRINT_NO_CODE) ;
	3311
	3312	macro.count++ ;
	3313	if (macro.level)
	3314	return PrintError(ERR_EMBEDDED_MACRO) ;
	3315	else
	3316	if (run.pass == MACROPASS)
	3317	{
	3318	current_macro->next = malloc(sizeof(struct MACROLIST)) ;
	3319	current_macro = current_macro->next ;
	3320	current_macro->next = NULL ;
	3321	current_macro->count = macro.count ;
	3322	current_macro->line = run.line ;
	3323	current_macro->start = source ;
	3324	current_macro->end = NULL ;
	3325	}
	3326	else {
	3327	/* Erreur si une macro a déjà été déclarée */
	3328	if (run.locked & MACRO_LOCK)
	3329	return PrintError(ERR_EMBEDDED_MACRO) ;
	3330	/* Erreur si le nom de la macro est réservé */
	3331	if (CheckIfReservedName() != NO_ERROR)
	3332	return ERR_ERROR ;
	3333	/* Erreur éventuelle si assemblage conditionnel en cours */
	3334	if ((ifc.count > 0) && (scan.soft == SOFT_MACROASSEMBLER))
	3335	return PrintError(ERR_MACRO_INTO_IF_RANGE) ;
	3336	/* Déclare la macro */
	3337	if (DoSymbol(labelname,macro.count,MACRO_VALUE) != NO_ERROR)
	3338	return ERR_ERROR ;
	3339	/* Active le bit macro */
	3340	run.locked \|= MACRO_LOCK ;
	3341	RecordLine(PRINT_NO_CODE) ;
	3342	}
	3343	return NO_ERROR ;
	3344	}
	3345
	3346
	3347	int Ass_ENDM(void)
	3348	{
	3349	struct MACROARGLIST *prev_macroarg ;
	3350
	3351	if (run.locked & (COMMENT_LOCK + IF_LOCK))
	3352	return RecordLine(PRINT_NO_CODE) ;
	3353
	3354	if (macro.level)
	3355	{
	3356	if (current_macroarg->prev == NULL)
	3357	return PrintError(ERR_ENDM_WITHOUT_MACRO) ;
	3358	prev_macroarg = current_macroarg->prev ;
	3359	free(current_macroarg) ;
	3360	current_macroarg = prev_macroarg ;
	3361	source = current_macroarg->ptr ;
	3362	run.line = current_macroarg->line ;
	3363	macro.level-- ;
	3364	return NO_ERROR ;
	3365	}
	3366	else
	3367	if (run.pass == MACROPASS)
	3368	{
	3369	if (current_macro->end != NULL)
	3370	return PrintError(ERR_ENDM_WITHOUT_MACRO) ;
	3371	current_macro->end = source ;
	3372	}
	3373	else
	3374	if ((run.locked & MACRO_LOCK) == 0)
	3375	return PrintError(ERR_ENDM_WITHOUT_MACRO) ;
	3376
	3377	run.locked &= ~MACRO_LOCK ;
	3378	return RecordLine(PRINT_NO_CODE) ;
	3379	}
	3380
	3381	/*-------------------------------------------------------------------
	3382	* Assemblage des autres directives
	3383	*/
	3384
	3385	int Ass_ORG(void)
	3386	{
	3387	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3388	run.pc = eval.operand ;
	3389	return RecordLine(PRINT_PC) ;
	3390	}
	3391
	3392	int Ass_SETDP(void)
	3393	{
	3394	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3395	if((eval.operand < -256) \|\| (eval.operand > 255))
	3396	return PrintError(ERR_BAD_OPERAND) ;
	3397	run.dp = eval.operand & 0xFF ;
	3398	return RecordLine(PRINT_LIKE_DP) ;
	3399	}
	3400
	3401	int Ass_END(void)
	3402	{
	3403	eval.operand = 0 ;
	3404	if ((*line != '\0')
	3405	&& (*line != ' ')
	3406	&& (*line != CHAR127))
	3407	{
	3408	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3409	run.exec = eval.operand ;
	3410	}
	3411	run.exit = TRUE ;
	3412	return RecordLine(PRINT_LIKE_END) ;
	3413	}
	3414
	3415	int Ass_OPT(void)
	3416	{
	3417	const struct {
	3418	char name[3] ; /* Nom du switch d'option */
	3419	int type ; /* Code du switch d'option */
	3420	} OptTable[6] = {
	3421	{ "NO", OPT_NO }, /* Pas d'objet */
	3422	{ "OP", OPT_OP }, /* Optimisation */
	3423	{ "SS", OPT_SS }, /* Lignes séparées (inactif) */
	3424	{ "WE", OPT_WE }, /* Attend à l'erreur (inactif) */
	3425	{ "WL", OPT_WL }, /* Affiche lignes */
	3426	{ "WS", OPT_WS } /* Affiche symboles */
	3427	} ;
	3428
	3429	int i ;
	3430	int status ;
	3431
	3432	if ((*line == '\0')
	3433	\|\| ((run.pass != SCANPASS) && (run.pass != PASS2)))
	3434	return NO_ERROR ;
	3435	do
	3436	{
	3437	status = TRUE ;
	3438	if (*line == '.') { status = FALSE ; line++ ; }
	3439	if (ScanLine() != ALPHA_CHAR)
	3440	return PrintError(ERR_BAD_PARAM) ;
	3441	upper_string(arg) ;
	3442	i = 0 ;
	3443	while ((i < 6) && (strcmp(arg,OptTable[i].name))) i++ ;
	3444	if (i == 6)
	3445	return PrintError(ERR_BAD_PARAM) ;
	3446	run.opt[OptTable[i].type] = status ;
	3447	} while((ScanLine() != END_CHAR) && (*arg == '/')) ;
	3448
	3449	return RecordLine(PRINT_NO_CODE) ;
	3450	}
	3451
	3452	/*-------------------------------------------------------------------
	3453	* Liste des directives
	3454	*/
	3455	enum {
	3456	NO_LABEL, /* Pas d'étiquette */
	3457	LABEL, /* Etiquette éventuelle */
	3458	A_LABEL /* Etiquette obligatoire */
	3459	} ;
	3460	const struct DIRECTTABLE {
	3461	char name[7] ; /* Nom de la directive */
	3462	int iflabel ; /* NO_LABEL/LABEL/A_LABEL */
	3463	int soft ; /* SOFT_ASSEMBLER/SOFT_MACROASSEMBLER */
	3464	int ifprint ; /* TRUE = exécution inconditionnelle */
	3465	int ifuppercase ; /* Pour création de fichiers Assembler
	3466	* TRUE = Opérande supposée
	3467	* FALSE = Pas d'opérande */
	3468	int (prog)(void) ; / Programme de traitement */
	3469	} direct_table[] = {
	3470	{ "CALL" , LABEL , SOFT_MACROASSEMBLER, FALSE, TRUE , Ass_CALL },
	3471	{ "ECHO" , NO_LABEL, SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_ECHO },
	3472	{ "ELSE" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , FALSE, Ass_ELSE },
	3473	{ "END" , NO_LABEL, SOFT_ASSEMBLER , FALSE, TRUE , Ass_END },
	3474	{ "ENDC" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , FALSE, Ass_ENDC },
	3475	{ "ENDM" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , FALSE, Ass_ENDM },
	3476	{ "EQU" , A_LABEL , SOFT_ASSEMBLER , FALSE, TRUE , Ass_EQU },
	3477	{ "FCB" , LABEL , SOFT_ASSEMBLER , FALSE, TRUE , Ass_FCB },
	3478	{ "FCC" , LABEL , SOFT_ASSEMBLER , FALSE, FALSE, Ass_FCC },
	3479	{ "FCN" , LABEL , SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_FCN },
	3480	{ "FCS" , LABEL , SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_FCS },
	3481	{ "FDB" , LABEL , SOFT_ASSEMBLER , FALSE, TRUE , Ass_FDB },
	3482	{ "GOTO" , LABEL , SOFT_MACROASSEMBLER, FALSE, TRUE , Ass_GOTO },
	3483	{ "IF" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IF },
	3484	{ "IFEQ" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFEQ },
	3485	{ "IFGE" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFGE },
	3486	{ "IFGT" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFGT },
	3487	{ "IFLE" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFLE },
	3488	{ "IFLT" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFLT },
	3489	{ "IFNE" , NO_LABEL, SOFT_MACROASSEMBLER, TRUE , TRUE , Ass_IFNE },
	3490	{ "INCBIN" , NO_LABEL, SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_INCBIN },
	3491	{ "INCDAT" , NO_LABEL, SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_INCDAT },
	3492	{ "INCLUD" , NO_LABEL, SOFT_ASSEMBLER , FALSE, FALSE, Ass_INCLUD },
	3493	{ "MACRO" , A_LABEL , SOFT_MACROASSEMBLER, TRUE , FALSE, Ass_MACRO },
	3494	{ "OPT" , NO_LABEL, SOFT_MACROASSEMBLER, FALSE, TRUE , Ass_OPT },
	3495	{ "ORG" , NO_LABEL, SOFT_ASSEMBLER , FALSE, TRUE , Ass_ORG },
	3496	{ "PAGE" , NO_LABEL, SOFT_ASSEMBLER , FALSE, FALSE, Ass_PAGE },
	3497	{ "PRINT" , NO_LABEL, SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_PRINT },
	3498	{ "RMB" , LABEL , SOFT_ASSEMBLER , FALSE, TRUE , Ass_RMB },
	3499	{ "RMD" , LABEL , SOFT_MACROASSEMBLER, FALSE, TRUE , Ass_RMD },
	3500	{ "SET" , A_LABEL , SOFT_ASSEMBLER , FALSE, TRUE , Ass_SET },
	3501	{ "SETDP" , NO_LABEL, SOFT_ASSEMBLER , FALSE, TRUE , Ass_SETDP },
	3502	{ "STOP" , LABEL , SOFT_MACROASSEMBLER, FALSE, FALSE, Ass_STOP },
	3503	{ "TITLE" , NO_LABEL, SOFT_ASSEMBLER , FALSE, FALSE, Ass_TITLE }
	3504	};
	3505	#define DTSIZE (int)sizeof(direct_table)/(int)sizeof(direct_table[0])
	3506
	3507	/*
	3508	* Vérifie si le nom de macro est réservé
	3509	*/
	3510	int CheckIfReservedName(void)
	3511	{
	3512	int i ;
	3513	char macrname[ARG_MAX_SIZE+2] ;
	3514
	3515	macrname[0] = '\0' ;
	3516	strcat(macrname,labelname) ;
	3517	upper_string(macrname) ;
	3518
	3519	/* Vérifie si le nom de macro est celui d'une instruction */
	3520	for(i=0;i<ITSIZE;i++)
	3521	if (!strcmp(inst_table[i].name,macrname))
	3522	return PrintError(ERR_BAD_MACRO_NAME) ;
	3523
	3524	/* Vérifie si le nom de macro est celui d'une directive */
	3525	for(i=0;i<DTSIZE;i++)
	3526	if (!strcmp(direct_table[i].name,macrname))
	3527	return PrintError(ERR_BAD_MACRO_NAME) ;
	3528
	3529	return NO_ERROR ;
	3530	}
	3531
	3532
	3533	/***********************************************************************
	3534	*
	3535	* Assemblage de la ligne de code
	3536	*
	3537	***********************************************************************/
	3538
	3539	/*
	3540	* Passe les espaces
	3541	*/
	3542	void SkipSpaces(void)
	3543	{
	3544	while(*line == 0x20)
	3545	line++ ;
	3546	}
	3547
	3548	/*
	3549	* Initialise le chaînage des arguments de macros
	3550	*/
	3551	void InitMacroArgChain(void)
	3552	{
	3553	int i ;
	3554	current_macroarg = malloc(sizeof(struct MACROARGLIST)) ;
	3555	current_macroarg->prev = NULL ;
	3556	for(i=0;i<10;i++) current_macroarg->arg[i] = NULL ;
	3557	}
	3558
	3559	/*
	3560	* Libère la mémoire pour le chaînage des arguments de macros
	3561	*/
	3562	void FreeMacroArgChain(void)
	3563	{
	3564	struct MACROARGLIST *last_macroarg ;
	3565	while((last_macroarg = current_macroarg))
	3566	{
	3567	current_macroarg = current_macroarg->prev ;
	3568	free(last_macroarg) ;
	3569	}
	3570	}
	3571
	3572	/*
	3573	* Assemble la ligne
	3574	*/
	3575	int AssembleLine(void)
	3576	{
	3577	struct MACROARGLIST *prev_macroarg ;
	3578	struct INCLIST *prev_includ = NULL ;
	3579	int i ;
	3580	int done = FALSE ;
	3581	int label = FALSE ;
	3582	char macroname[ARG_MAX_SIZE+2] ;
	3583	char argname[ARG_MAX_SIZE+2] ;
	3584	char ll[LINE_MAX_SIZE+2] ;
	3585	int argn ;
	3586	int error = NO_ERROR ;
	3587
	3588	run.size = 0 ;
	3589	info.cycle.count = -1 ;
	3590	info.cycle.plus = -1 ;
	3591
	3592	/* Retour éventuel d'includ */
	3593	if ((first_includ->count != 0)
	3594	&& (source == first_includ->end))
	3595	{
	3596	prev_includ = first_includ->prev ;
	3597	free(first_includ) ;
	3598	first_includ = prev_includ ;
	3599	run.line = first_includ->line ;
	3600	source = first_includ->start ;
	3601	}
	3602
	3603	GetLine() ;
	3604
	3605	if (*line == '\0') return RecordLine(PRINT_EMPTY) ;
	3606
	3607	/*
	3608	* Traitement du marquage
	3609	*/
	3610	if ((*line == '(') && (run.pass == PASS2))
	3611	{
	3612	line++ ;
	3613	ScanLine() ;
	3614	if (!strcmp(arg,"info"))
	3615	{
	3616	fprintf(fp_lst,"----------------\n") ;
	3617	fprintf(fp_lst,"%d cycle(s)\n",info.cycle.total) ;
	3618	fprintf(fp_lst,"%d byte(s)\n",info.size) ;
	3619	fprintf(fp_lst,"----------------\n") ;
	3620	info.cycle.total = 0 ;
	3621	info.size = 0 ;
	3622	}
	3623	else
	3624	if (!strcmp(arg,"check"))
	3625	{
	3626	line++ ;
	3627	SkipSpaces() ;
	3628	if(*line == '\0')
	3629	{
	3630	check[0][0] = 0 ; /* Cycles limite */
	3631	check[0][1] = 0 ; /* Cycles */
	3632	check[1][0] = 0 ; /* Taille limite */
	3633	check[1][1] = 0 ; /* Taille */
	3634	}
	3635	else
	3636	{
	3637	i = 0 ;
	3638	while ((*line > 0x20) && (i < 2))
	3639	{
	3640	if ((*line != ',')
	3641	&& (*line > 0x20))
	3642	{
	3643	if (Eval() != NO_ERROR) return ERR_ERROR ;
	3644	check[i][0] = eval.operand ;
	3645	if ((check[i][0] != 0)
	3646	&& (check[i][0] != check[i][1]))
	3647	{
	3648	PrintError(ERR_CHECK_ERROR) ;
	3649	printf("Check[%d,%d]\n",check[0][1],check[1][1]) ;
	3650	fprintf(fp_lst,"Check [%d,%d]\n",check[0][1],check[1][1]) ;
	3651	}
	3652	}
	3653	if (*line == ',') line++ ;
	3654	}
	3655	check[0][1] = 0 ;
	3656	check[1][1] = 0 ;
	3657	}
	3658	}
	3659	return NO_ERROR ;
	3660	}
	3661
	3662	/*
	3663	* Reconstruction de la ligne si exécution de macro
	3664	*/
	3665	if (macro.level)
	3666	{
	3667	i = 0 ;
	3668	ll[0] = '\0' ;
	3669	while (linebuffer[i] != 0)
	3670	{
	3671	if (linebuffer[i] == '\\')
	3672	{
	3673	i++ ;
	3674	/* Récupère le numéro de l'argument de macro */
	3675	if (is_numeric(linebuffer[i]) == FALSE)
	3676	return PrintError(ERR_MACRO_ERROR) ;
	3677	argn = linebuffer[i++] - '0' ;
	3678	/* Interprète l'argument de macro */
	3679	prev_macroarg = current_macroarg ;
	3680	while((prev_macroarg->arg[argn] != NULL)
	3681	&& (prev_macroarg->arg[argn][0] == '\\'))
	3682	{
	3683	if (prev_macroarg->prev == NULL)
	3684	return PrintError(ERR_MACRO_ERROR) ;
	3685	if (is_numeric(prev_macroarg->arg[argn][1]) == FALSE)
	3686	return PrintError(ERR_MACRO_ERROR) ;
	3687	argn = prev_macroarg->arg[argn][1] - '0' ;
	3688	prev_macroarg = prev_macroarg->prev ;
	3689	}
	3690	if (prev_macroarg->arg[argn] != NULL)
	3691	strcat(ll,prev_macroarg->arg[argn]) ;
	3692	}
	3693	else
	3694	strncat(ll,&linebuffer[i++],1) ;
	3695	}
	3696	linebuffer[0] = '\0' ;
	3697	strcat(linebuffer,ll) ;
	3698	}
	3699
	3700	/*
	3701	* Traitement étiquette/commentaire
	3702	*/
	3703	if (*line != 0x20)
	3704	{
	3705	/* Traitement du slash de commentaire */
	3706	if (*line == '/') {
	3707	run.locked ^= COMMENT_LOCK ;
	3708	return RecordLine(PRINT_NO_CODE) ; }
	3709	/* Traitement de l'astérisque de commentaire */
	3710	if ((line == '')
	3711	\|\| (run.locked & COMMENT_LOCK))
	3712	return RecordLine(PRINT_NO_CODE) ;
	3713	/* Lecture de l'étiquette */
	3714	if (ScanLine() != ALPHA_CHAR)
	3715	return PrintError(ERR_BAD_LABEL) ;
	3716	if (((scan.soft == SOFT_ASSEMBLER) && ((int)strlen(arg) > 6))
	3717	\|\| ((scan.soft == SOFT_MACROASSEMBLER) && ((int)strlen(arg) > ARG_MAX_SIZE)))
	3718	return PrintError(ERR_LABEL_NAME_TOO_LONG) ;
	3719	labelname[0] = '\0' ;
	3720	strcat(labelname,arg) ;
	3721	if (scan.soft == SOFT_ASSEMBLER)
	3722	upper_string(labelname) ;
	3723	label = TRUE ;
	3724	}
	3725
	3726	/*
	3727	* Traitement étiquette sèche
	3728	*/
	3729	SkipSpaces() ;
	3730	if ((*line == '\0')
	3731	\|\| (line == ''))
	3732	{
	3733	if ((label == TRUE)
	3734	&& (run.pass > MACROPASS))
	3735	{
	3736	if (DoSymbol(labelname,run.pc,LABEL_VALUE) != NO_ERROR)
	3737	return ERR_ERROR ;
	3738	return RecordLine(PRINT_PC) ;
	3739	}
	3740	return RecordLine(PRINT_NO_CODE) ;
	3741	}
	3742
	3743	/*
	3744	* Récupération de l'instruction
	3745	*/
	3746	if (ScanLine() != ALPHA_CHAR)
	3747	return PrintError(ERR_BAD_OPCODE) ;
	3748	SkipSpaces() ;
	3749	macroname[0] = '\0' ;
	3750	strcat(macroname,arg) ;
	3751
	3752	run.size = 0 ;
	3753	run.code[0] = 0 ;
	3754
	3755	/* Traitement de l'instruction */
	3756
	3757	upper_string(arg) ;
	3758	if (run.pass > MACROPASS)
	3759	{
	3760	i = 0 ;
	3761	while((i<ITSIZE) && (done == FALSE))
	3762	{
	3763	if(!strcmp(inst_table[i].name,arg))
	3764	{
	3765	run.code[0] = inst_table[i].page ;
	3766	run.code[1] = inst_table[i].code ;
	3767	info.cycle.count = inst_table[i].cycles ;
	3768	if (run.locked == UNLOCKED)
	3769	{
	3770	if ((label == TRUE)
	3771	&& (DoSymbol(labelname,run.pc,LABEL_VALUE) != NO_ERROR))
	3772	return ERR_ERROR ;
	3773	upper_string(arg) ;
	3774	error = (*inst_table[i].prog)() ;
	3775	}
	3776	else RecordLine(PRINT_NO_CODE) ;
	3777	done = TRUE ;
	3778	}
	3779	i++ ;
	3780	}
	3781	}
	3782
	3783	/* Traitement de la directive */
	3784
	3785	if (done == FALSE)
	3786	{
	3787	i = 0 ;
	3788	while((i<DTSIZE) && (done == FALSE))
	3789	{
	3790	if(!strcmp(direct_table[i].name,arg))
	3791	{
	3792	if ((scan.soft == SOFT_ASSEMBLER)
	3793	&& (direct_table[i].soft != SOFT_ASSEMBLER))
	3794	return PrintError(ERR_BAD_OPCODE) ;
	3795
	3796	/* Au pass de macro, seules les directives
	3797	* MACRO et ENDM doivent passer
	3798	* Aux pass 1 et 2, seules les directives
	3799	* qui ne se trouvent ni dans une zone de
	3800	* commentaire, ni dans une déclaration de
	3801	* macro, ni dans un IF faux (sauf les
	3802	* directives de condition, etc...) doivent
	3803	* passer */
	3804	if (((run.pass == MACROPASS)
	3805	&& (strcmp(direct_table[i].name,"MACRO"))
	3806	&& (strcmp(direct_table[i].name,"ENDM")))
	3807	\|\| ((run.pass > MACROPASS)
	3808	&& (run.locked)
	3809	&& (direct_table[i].ifprint == FALSE)))
	3810	return RecordLine(PRINT_NO_CODE) ;
	3811
	3812	switch (direct_table[i].iflabel)
	3813	{
	3814	case NO_LABEL :
	3815	if (label == TRUE)
	3816	return PrintError(ERR_ILLEGAL_LABEL) ;
	3817	break ;
	3818	case A_LABEL :
	3819	if (label == FALSE)
	3820	return PrintError(ERR_MISSING_LABEL) ;
	3821	break ;
	3822	case LABEL :
	3823	if ((label == TRUE)
	3824	&& (DoSymbol(labelname,run.pc,LABEL_VALUE) != NO_ERROR))
	3825	return ERR_ERROR ;
	3826	break ;
	3827	}
	3828	error = (*direct_table[i].prog)() ;
	3829	done = TRUE ;
	3830	}
	3831	i++ ;
	3832	}
	3833	}
	3834
	3835
	3836	/* Traitement de la macro */
	3837	if ((done == FALSE) && (run.pass > MACROPASS))
	3838	{
	3839	if (scan.soft == SOFT_ASSEMBLER)
	3840	return PrintError(ERR_BAD_OPCODE) ;
	3841	if (run.locked)
	3842	return RecordLine(PRINT_NO_CODE) ;
	3843	if (DoSymbol(macroname,0,READ_VALUE) != NO_ERROR)
	3844	return ERR_ERROR ;
	3845	if (eval.type != MACRO_VALUE)
	3846	return PrintError(ERR_UNDEFINED_MACRO) ;
	3847
	3848	/* Limite le nombre d'imbrications */
	3849	if ((macro.level == 8)
	3850	&& (scan.soft == SOFT_MACROASSEMBLER))
	3851	return PrintError(ERR_MACRO_OUT_OF_RANGE) ;
	3852	macro.level++ ;
	3853
	3854	/* Sauvegarde les arguments de macro */
	3855	current_macroarg->line = run.line ;
	3856	current_macroarg->ptr = source ;
	3857	prev_macroarg = current_macroarg ;
	3858	current_macroarg = malloc(sizeof(struct MACROARGLIST)) ;
	3859	current_macroarg->prev = prev_macroarg ;
	3860	for(i=0;i<10;i++) current_macroarg->arg[i] = NULL ;
	3861	if (*line != '\0')
	3862	{
	3863	i = 0 ;
	3864	while ((*line != '\0')
	3865	&& (*line != ' ')
	3866	&& (i < 10))
	3867	{
	3868	if ((i) && (*(line++) != ','))
	3869	return PrintError(ERR_MACRO_ERROR) ;
	3870	argname[0] = '\0' ;
	3871	while((*line != '\0')
	3872	&& (*line != ' ')
	3873	&& (*line != ','))
	3874	strncat(argname,line++,1) ;
	3875	current_macroarg->arg[i] = malloc(strlen(argname)+1) ;
	3876	current_macroarg->arg[i][0] = '\0' ;
	3877	strcat(current_macroarg->arg[i],argname) ;
	3878	i++ ;
	3879	}
	3880	}
	3881	/* Recherche la macro dans la liste */
	3882	current_macro = first_macro ;
	3883	while(current_macro->count != (unsigned short)eval.operand)
	3884	current_macro = current_macro->next ;
	3885	/* Lance l'exécution de la macro */
	3886	source = current_macro->start ;
	3887	run.line = current_macro->line ;
	3888	}
	3889
	3890	/* Effectue le total des cycles */
	3891	if (info.cycle.count != -1)
	3892	{
	3893	info.cycle.total += info.cycle.count ;
	3894	check[0][1] += info.cycle.count ;
	3895	}
	3896	if (info.cycle.plus != -1)
	3897	{
	3898	info.cycle.total += info.cycle.plus ;
	3899	check[0][1] += info.cycle.plus ;
	3900	}
	3901
	3902	/* Sauvegarde des octets de code */
	3903	if ((run.size != 0) && (error == NO_ERROR))
	3904	{
	3905	if(run.code[0])
	3906	SaveBinChar(run.code[0]) ;
	3907	for(i=0;i<run.size;i++)
	3908	SaveBinChar(run.code[i+1]) ;
	3909	}
	3910
	3911	return NO_ERROR ;
	3912	}
	3913
	3914
	3915
	3916
	3917	/***********************************************************************
	3918	*
	3919	* Chargement et traitement du fichier source
	3920	*
	3921	***********************************************************************/
	3922
	3923	enum{
	3924	NO_MARK,
	3925	MAIN_MARK,
	3926	INFO_MARK,
	3927	CHECK_MARK,
	3928	INCLUDE_MARK
	3929	} ;
	3930
	3931	const struct {
	3932	char name[8] ; /* Nom du marquage */
	3933	int type ; /* Type du marquage */
	3934	} mark[] = {
	3935	{ "main" , MAIN_MARK },
	3936	{ "info" , INFO_MARK },
	3937	{ "check" , CHECK_MARK },
	3938	{ "include", INCLUDE_MARK }
	3939	} ;
	3940	#define MTSIZE (int)sizeof(mark)/(int)sizeof(mark[0])
	3941
	3942	struct {
	3943	int status ; /* TRUE = création des fichiers ASM */
	3944	int comment ; /* Flag de passage d'un '/' de commentaire */
	3945	int top ; /* Compteur de lignes vides de début de source */
	3946	int bottom ; /* Compteur de lignes vides de fin de source */
	3947	} create ;
	3948
	3949
	3950	/*
	3951	* Initialise le chaînage des sources
	3952	*/
	3953	void InitSourceChain(void)
	3954	{
	3955	first_source = malloc(sizeof(struct SRCLIST)) ;
	3956	first_source->next = NULL ;
	3957	first_source->start = NULL ;
	3958	}
	3959
	3960
	3961	/*
	3962	* Libère la mémoire pour le chaînage des sources
	3963	*/
	3964	void FreeSourceChain(void)
	3965	{
	3966	while((current_source = first_source))
	3967	{
	3968	first_source = first_source->next ;
	3969	free(current_source) ;
	3970	}
	3971	}
	3972
	3973
	3974	/*
	3975	* Ferme le fichier ASM courant
	3976	*/
	3977	void CloseASM(void)
	3978	{
	3979	if (fp_asm != NULL)
	3980	fclose(fp_asm) ;
	3981	}
	3982
	3983
	3984	int RecordSourceChainIf(void)
	3985	{
	3986	int i = 0 ;
	3987	int accent ;
	3988	int markflag = NO_MARK ;
	3989	struct SRCLIST *next_source ;
	3990	char crunchedline[ARG_MAX_SIZE+2] ;
	3991	char *p = line ;
	3992	unsigned char c = '\0' ;
	3993	int spaces = 0 ;
	3994
	3995	int done = FALSE ;
	3996	int flag = FALSE ;
	3997	int csize = 0 ;
	3998
	3999	/*
	4000	* Crée la ligne au format ASM
	4001	*/
	4002	if (*line != '(')
	4003	{
	4004	while((*line != '\0') && ((line - p) < COLON_40))
	4005	{
	4006	/* Filtre les caractères */
	4007	switch(c = (unsigned char)*(line++))
	4008	{
	4009	case CHAR127 : c = 0x7F ; break ;
	4010	case 0x20 :
	4011	spaces++ ;
	4012	while(*line == 0x20)
	4013	{
	4014	spaces++ ;
	4015	line++ ;
	4016	}
	4017	break ;
	4018	default :
	4019	if (c > 0x7F)
	4020	{
	4021	accent = 0 ;
	4022	while((accent<16) && (c != acc_table[accent])) accent++ ;
	4023	if (accent == 16) c = '?' ; else c = 0x80 + accent ;
	4024	}
	4025	break ;
	4026	}
	4027	/* Ajoute un caractère si valide */
	4028	if (c > 0x20)
	4029	{
	4030	/* Ajoute les lignes vides préalables */
	4031	if (create.top)
	4032	{
	4033	while(create.bottom > 0)
	4034	{
	4035	if ((fp_asm != NULL) && (create.status == TRUE))
	4036	fputc(0x0D,fp_asm) ;
	4037	current_source->asm_size += create.bottom * 3 ;
	4038	create.bottom-- ;
	4039	}
	4040	}
	4041	create.bottom = 0 ;
	4042
	4043	/* Ajoute les espaces préalables */
	4044	while (spaces >= 15)
	4045	{
	4046	crunchedline[csize++] = (char)0xFF ;
	4047	spaces -= 15 ;
	4048	}
	4049	if (spaces) crunchedline[csize++] = spaces \| 0xF0 ;
	4050	spaces = 0 ;
	4051
	4052	/* Ajoute le caractère */
	4053	crunchedline[csize++] = c ;
	4054	}
	4055	}
	4056	crunchedline[csize++] = 0x0D ;
	4057	if (crunchedline[0] != 0x0D) create.top = 1 ;
	4058	else if (create.top) create.bottom++ ;
	4059	if ((create.top != 0) && (create.bottom == 0))
	4060	{
	4061	current_source->asm_size += 3 + csize - 1 ;
	4062
	4063	/*
	4064	* Capitalise les lettres si compatibilité Assembler demandée
	4065	*/
	4066
	4067	if ((scan.soft == SOFT_ASSEMBLER)
	4068	&& (create.status == TRUE))
	4069	{
	4070	line = &crunchedline[0] ;
	4071	/* Traitement de l'étiquette */
	4072	if (*line == '/') create.comment ^= COMMENT_LOCK ;
	4073	else
	4074	if ((create.comment == 0)
	4075	&& (*line != '\0')
	4076	&& (line != '')
	4077	&& (*line != '/'))
	4078	{
	4079	while (((unsigned char)line <= 0xF0) && (line != 0x0D))
	4080	{
	4081	(line) = upper_case((unsigned char)(line)) ;
	4082	line++ ;
	4083	}
	4084	while ((unsigned char)*line > 0xF0) line++ ;
	4085
	4086	/* Traitement de l'instruction/directive/macro */
	4087	if ((line != 0x0D) && (line != '*'))
	4088	{
	4089	i = 0 ;
	4090	while (((unsigned char)line <= 0xF0) && (line != 0x0D))
	4091	{
	4092	line = upper_case(line) ;
	4093	arg[i++] = *(line++) ;
	4094	}
	4095	arg[i] = '\0' ;
	4096	while ((unsigned char)*line > 0xF0) line++ ;
	4097
	4098	if (*line != 0x0D)
	4099	{
	4100	/* Recherche si opérande pour instruction */
	4101	upper_string(arg) ;
	4102	i = 0 ;
	4103	while((i<ITSIZE) && (done == FALSE))
	4104	{
	4105	if(!strcmp(inst_table[i].name,arg))
	4106	{
	4107	flag = inst_table[i].ifuppercase ;
	4108	done = TRUE ;
	4109	}
	4110	i++ ;
	4111	}
	4112
	4113	/* Recherche si opérande pour directive */
	4114	i = 0 ;
	4115	while((i<DTSIZE) && (done == FALSE))
	4116	{
	4117	if(!strcmp(direct_table[i].name,arg))
	4118	{
	4119	flag = direct_table[i].ifuppercase ;
	4120	done = TRUE ;
	4121	}
	4122	i++ ;
	4123	}
	4124
	4125	/* Traitement de l'opérande éventuelle */
	4126	if ((done == TRUE) && (flag == TRUE))
	4127	{
	4128	while (((unsigned char)line < 0xF0) && (line != 0x0D))
	4129	{
	4130	if ((*line == '\'')
	4131	&& (*(line + 1) != 0x0D))
	4132	line++ ;
	4133	else
	4134	line = upper_case((unsigned char)line) ;
	4135	line++ ;
	4136	}
	4137	}
	4138	}
	4139	}
	4140	}
	4141	}
	4142
	4143	/*
	4144	* Sauvegarde éventuellement la ligne au format ASM
	4145	*/
	4146
	4147	if ((fp_asm != NULL)
	4148	&& (create.status == TRUE))
	4149	fwrite(crunchedline,sizeof(char),csize,fp_asm) ;
	4150	}
	4151	return NO_ERROR ;
	4152	}
	4153
	4154	/* Vérifie la validité du marquage */
	4155	line++ ;
	4156	if (ScanLine() != ALPHA_CHAR)
	4157	return PrintError(ERR_WRONG_MARK) ;
	4158	for(i=0;i<MTSIZE;i++)
	4159	if (!strcmp(arg,mark[i].name))
	4160	markflag = mark[i].type ;
	4161	if (markflag == NO_MARK)
	4162	return PrintError(ERR_WRONG_MARK) ;
	4163	if(*(line++) != ')')
	4164	return PrintError(ERR_WRONG_MARK) ;
	4165
	4166	/* Traite le marquage */
	4167	switch(markflag)
	4168	{
	4169	case MAIN_MARK :
	4170	case INCLUDE_MARK :
	4171	CloseASM() ;
	4172	SkipSpaces() ;
	4173	if (GetDescriptor("ASM") != NO_ERROR)
	4174	return ERR_ERROR ;
	4175	/* Vérifie l'unicité du nom de source */
	4176	next_source = first_source ;
	4177	do {
	4178	current_source = next_source ;
	4179	if (!strcmp(current_source->name,desc.name))
	4180	return PrintError(ERR_DUPLICATE_NAME) ;
	4181	} while((next_source = next_source->next) != NULL) ;
	4182
	4183	/* Enregistre la déclaration */
	4184	switch(markflag)
	4185	{
	4186	case MAIN_MARK :
	4187	/* Met à jour le 'main' */
	4188	current_source = first_source ;
	4189	if (current_source->start != NULL)
	4190	return PrintError(ERR_DUPLICATE_MAIN) ;
	4191	break ;
	4192	case INCLUDE_MARK :
	4193	/* Chaîne l'include */
	4194	current_source->next = malloc(sizeof(struct SRCLIST)) ;
	4195	current_source = current_source->next ;
	4196	current_source->next = NULL ;
	4197	break ;
	4198	}
	4199	/* Enregistre les paramètres de l'include */
	4200	current_source->drive = desc.drive ;
	4201	current_source->name[0] = '\0' ;
	4202	strcat(current_source->name,desc.name) ;
	4203	current_source->line = run.line ;
	4204	current_source->start = source ;
	4205	current_source->asm_size = 0 ;
	4206	create.top = 0 ;
	4207	create.bottom = 0 ;
	4208	create.comment = 0 ;
	4209	/* Ouvre le fichier suivant */
	4210	if (create.status == TRUE)
	4211	fp_asm = fopen(current_source->name,"wb") ;
	4212	break ;
	4213	}
	4214	return NO_ERROR ;
	4215	}
	4216
	4217
	4218	/*
	4219	* Chargement du fichier source
	4220	*/
	4221	int LoadFile(char *name)
	4222	{
	4223	FILE *fp_file ;
	4224
	4225	int fsize = 1 ;
	4226	int error ;
	4227
	4228	if (!(fp_file = fopen(name,"rb")))
	4229	{
	4230	printf("*** Impossible d'ouvrir '%s'\n",name) ;
	4231	return ERR_ERROR ;
	4232	}
	4233	fseek(fp_file, 0, SEEK_END) ;
	4234	fsize = ftell(fp_file) ;
	4235	fclose(fp_file) ;
	4236	filebuffer = malloc(fsize+1) ;
	4237	fp_file = fopen(name,"rb") ;
	4238	fread(filebuffer, sizeof(char), fsize, fp_file) ;
	4239	fclose(fp_file) ;
	4240	filebuffer[fsize] = '\0' ;
	4241
	4242	run.line = 0 ;
	4243	source = filebuffer ;
	4244	current_source = first_source ;
	4245	while (source < filebuffer+fsize)
	4246	{
	4247	/* Sauve le pointeur de fin du source précédent */
	4248	current_source->end = source ;
	4249
	4250	/* Récupère la ligne */
	4251	if ((error = GetLine()) != NO_ERROR)
	4252	return PrintError(error) ;
	4253	RecordSourceChainIf() ;
	4254	}
	4255	CloseASM() ;
	4256	current_source->end = source ;
	4257	if (first_source->start == NULL)
	4258	return PrintError(ERR_MISSING_MAIN) ;
	4259
	4260	return NO_ERROR ;
	4261	}
	4262
	4263
	4264	/*
	4265	* Assemble le source
	4266	*/
	4267	void AssembleSource(int pass)
	4268	{
	4269	int i = 0 ;
	4270
	4271	const struct {
	4272	char string[11] ; /* Message de pass */
	4273	int type ; /* Code de pass */
	4274	} PassTable[3] = {
	4275	{ "Macro Pass", MACROPASS },
	4276	{ "Pass1" , PASS1 },
	4277	{ "Pass2" , PASS2 },
	4278	} ;
	4279
	4280	/* Notifie le pass d'assemblage */
	4281	run.pass = pass ;
	4282	if ((run.pass == MACROPASS)
	4283	&& (scan.soft == SOFT_ASSEMBLER))
	4284	return ;
	4285	while(PassTable[i].type != run.pass) i++ ;
	4286	fprintf(fp_lst,"%s\n", PassTable[i].string) ;
	4287	printf("%s\n", PassTable[i].string) ;
	4288
	4289	/* Initialise les variables d'assemblage */
	4290	run.exit = FALSE ;
	4291	macro.count = 0 ;
	4292	run.dp = 0x00 ;
	4293	run.pc = 0x0000 ;
	4294	run.exec = 0x0000 ;
	4295	ifc.count = 0 ;
	4296	ifc.buf[0] = IF_TRUE ;
	4297	run.locked = UNLOCKED ;
	4298	info.cycle.total = 0 ;
	4299	info.size = 0 ;
	4300	check[0][0] = 0 ;
	4301	check[0][1] = 0 ;
	4302	check[1][0] = 0 ;
	4303	check[1][1] = 0 ;
	4304	macro.level = 0 ;
	4305	memcpy(&run.opt, &scan.opt, sizeof(run.opt)) ;
	4306
	4307	/* Initialise les listes d'includes/arguments de macros */
	4308	InitIncludChain() ;
	4309	InitMacroArgChain() ;
	4310
	4311	/* Assemble les lignes des sources */
	4312	source = first_source->start ;
	4313	run.line = first_source->line ;
	4314	while((run.exit == FALSE)
	4315	&& (source != first_source->end))
	4316	AssembleLine() ;
	4317
	4318	/* Erreur si macro en cours */
	4319	if (run.locked & MACRO_LOCK)
	4320	PrintError(ERR_MISSING_ENDM) ;
	4321	/* Erreur si commentaire en cours */
	4322	if (run.locked & COMMENT_LOCK)
	4323	PrintError(ERR_MISSING_SLASH) ;
	4324	/* Traite les erreurs si pas END */
	4325	if (run.exit == FALSE)
	4326	{
	4327	/* Erreur si assemblage conditionnel en cours */
	4328	if (ifc.count != 0)
	4329	PrintError(ERR_MISSING_ENDC) ;
	4330	/* Erreur si ASSEMBLER et pas 'END' */
	4331	if (scan.soft == SOFT_ASSEMBLER)
	4332	PrintError(ERR_MISSING_END_STATEMENT) ;
	4333	}
	4334	/* Libère les listes d'includes/arguments de macros */
	4335	FreeIncludChain() ;
	4336	FreeMacroArgChain() ;
	4337	}
	4338
	4339
	4340
	4341	/***********************************************************************
	4342	*
	4343	* Programme principal
	4344	*
	4345	***********************************************************************/
	4346
	4347	/*
	4348	* Vérifie si pas de dépassement de capacité de l'ASM
	4349	*/
	4350	void CheckSourceSize(int size, char *name)
	4351	{
	4352	if (size > 29000)
	4353	{
	4354	fprintf(fp_lst,"*** Le fichier '%s' pourrait être trop grand pour être chargé\n", name) ;
	4355	printf("*** Le fichier '%s' pourrait etre trop grand pour etre charge\n", name) ;
	4356	}
	4357	}
	4358
	4359	/*
	4360	* Enregistre l'en-tête de listing
	4361	*/
	4362	void PrintListHeader(char fload, char fsave)
	4363	{
	4364	struct SRCLIST *current_source ;
	4365	fprintf(fp_lst,"/--------------------------------------------------------------\n") ;
	4366	fprintf(fp_lst," * Compilé avec C6809 v0.83 *\n") ;
	4367	fprintf(fp_lst," --------------------------------------------------------------\n") ;
	4368	fprintf(fp_lst," * Fichier source : %s\n",fload) ;
	4369	fprintf(fp_lst," * Fichier destination : %s\n",fsave) ;
	4370	fprintf(fp_lst," * Contenu :\n") ;
	4371	CheckSourceSize(first_source->asm_size, first_source->name) ;
	4372	fprintf(fp_lst," * Main %1d:%-12s %d\n",
	4373	first_source->drive,
	4374	first_source->name,
	4375	first_source->asm_size) ;
	4376	current_source = first_source ;
	4377	if ((current_source = current_source->next) != NULL)
	4378	{
	4379	do {
	4380	CheckSourceSize(current_source->asm_size, current_source->name) ;
	4381	fprintf(fp_lst," * Include %1d:%-12s %d\n",
	4382	current_source->drive,
	4383	current_source->name,
	4384	current_source->asm_size) ;
	4385	} while((current_source = current_source->next) != NULL) ;
	4386	}
	4387	fprintf(fp_lst," --------------------------------------------------------------/\n") ;
	4388	fprintf(fp_lst,"\n") ;
	4389	}
	4390
	4391	/*
	4392	* Referme toutes les déclarations
	4393	*/
	4394	int CloseAll(void)
	4395	{
	4396	/* Libération des mémoires */
	4397	FreeErrorChain() ; /* Erreurs */
	4398	FreeSymbolChain() ; /* Symboles */
	4399	FreeSourceChain() ; /* Sources */
	4400	FreeMacroChain() ; /* Macros */
	4401
	4402	/* Fermeture des fichiers */
	4403	fclose(fp_lst) ;
	4404	return 0 ;
	4405	}
	4406
	4407
	4408	/*
	4409	* Affichage de l'aide
	4410	*/
	4411	void PrintHelp(void)
	4412	{
	4413	printf("\n") ;
	4414	printf("Compilateur Macro/Assembler-like\n") ;
	4415	printf(" Francois MOURET (c) C6809 v 0.83 - mars 2010\n") ;
	4416	printf("\n") ;
	4417	printf("C6809 [options] fichier_source fichier_destination\n") ;
	4418	printf("\n") ;
	4419	printf(" options :\n") ;
	4420	printf(" -h aide de ce programme\n") ;
	4421	printf(" -o option(s) d'assemblage (NO, OP, SS, WE, WL et WS)\n") ;
	4422	printf(" les parametres d'option (tous desactives par defaut) doivent\n") ;
	4423	printf(" etre separes par des '/'\n") ;
	4424	printf(" -b type de la sortie (binaire non lineaire par defaut)\n") ;
	4425	printf(" l binaire lineaire\n") ;
	4426	printf(" h binaire hybride\n") ;
	4427	printf(" d donnee\n") ;
	4428	printf(" -d passage d'argument (<symbole>=<valeur>)\n") ;
	4429	printf(" -c cree les fichiers ASM au format Thomson\n") ;
	4430	printf(" -q notifie le depassement de 40 caracteres par ligne (300 par defaut)\n") ;
	4431	printf(" -e groupe les messages d'erreur du listing (ordre de ligne par defaut)\n") ;
	4432	printf(" -s ordre d'affichage des symboles du listing (alphabetique par defaut)\n") ;
	4433	printf(" e par erreur de symbole\n") ;
	4434	printf(" t par type de symbole\n") ;
	4435	printf(" n par frequence d'utilisation\n") ;
	4436	printf(" -a Notifie la compatibilite (assembleur virtuel par defaut)\n") ;
	4437	printf(" a ASSEMBLER1.0 et ASSEMBLER 2.0\n") ;
	4438	printf(" m MACROASSEMBLER 3.6\n") ;
	4439	printf(" -m + TO/TO7/MO machine de travail (TO par defaut)\n") ;
	4440	exit(CloseAll()) ;
	4441	}
	4442
	4443	/*
	4444	* Affichage de l'erreur et du conseil
	4445	*/
	4446	void PrintAdvice(char argument, char errorstring)
	4447	{
	4448	printf("*** %s : %s\n", argument, errorstring) ;
	4449	printf("Taper 'C6809 -h' pour afficher l'aide\n") ;
	4450	exit(CloseAll()) ;
	4451	}
	4452
	4453
	4454
	4455	/*
	4456	* Programme principal
	4457	*/
	4458	int main(int argc, char *argv[])
	4459	{
	4460	int i ;
	4461	int fcount = 0 ;
	4462	char label[ARG_MAX_SIZE+2] = "";
	4463	char my_argv[ARGV_MAX_SIZE] = "";
	4464	char fload[ARGV_MAX_SIZE] = "";
	4465	char fsave[ARGV_MAX_SIZE] = "";
	4466	int argp ;
	4467
	4468	const struct {
	4469	char name[4] ; /* Nom de l'option */
	4470	int type ; /* Code de l'option */
	4471	} Computer[3] = {
	4472	{ "TO" , TO_COMPUTER },
	4473	{ "TO7", TO7_COMPUTER },
	4474	{ "MO" , MO_COMPUTER }
	4475	} ;
	4476
	4477	/*
	4478	* Initialisation du programme
	4479	*/
	4480	memset(&bin, 0, sizeof(bin)) ;
	4481	bin.type = BIN_FILE ;
	4482	memset(&run, 0, sizeof(run)) ;
	4483	run.pass = SCANPASS ;
	4484	run.opt[OPT_NO] = FALSE ;
	4485	run.opt[OPT_OP] = FALSE ;
	4486	run.opt[OPT_SS] = FALSE ;
	4487	run.opt[OPT_WE] = FALSE ;
	4488	run.opt[OPT_WL] = FALSE ;
	4489	run.opt[OPT_WS] = FALSE ;
	4490	memset(&scan, 0, sizeof(scan)) ;
	4491	scan.computer = TO_COMPUTER ;
	4492	scan.soft = SOFT_UPDATE ;
	4493	scan.symb_order = INITIAL_ORDER ;
	4494	scan.err_order = INITIAL_ORDER ;
	4495	scan.limit = COLON_300 ;
	4496	scan.opt[OPT_NO] = FALSE ;
	4497	scan.opt[OPT_OP] = FALSE ;
	4498	scan.opt[OPT_SS] = FALSE ;
	4499	scan.opt[OPT_WE] = FALSE ;
	4500	scan.opt[OPT_WL] = FALSE ;
	4501	scan.opt[OPT_WS] = FALSE ;
	4502	memset(&macro, 0, sizeof(macro)) ;
	4503	memset(&create, 0, sizeof(create)) ;
	4504	create.status = FALSE ;
	4505	create.comment = 0 ;
	4506
	4507	/*
	4508	* Ouverture du fichier de liste
	4509	*/
	4510	if ((fp_lst = fopen("codes.lst","w")) == NULL) {
	4511	printf("*** Impossible d'ouvrir le fichier 'codes.lst'\n") ;
	4512	return 0 ; }
	4513
	4514	/* Initialisation des listes */
	4515	InitErrorChain() ; /* Erreurs */
	4516	InitSymbolChain() ; /* Symboles */
	4517	InitSourceChain() ; /* Sources */
	4518	InitMacroChain() ; /* Macros */
	4519
	4520	/*
	4521	* Traitement des arguments de lancement
	4522	*/
	4523	if(argc < 2) PrintHelp() ;
	4524
	4525	for(argp=1; argp<argc; argp++)
	4526	{
	4527	snprintf (my_argv, (strlen(argv[argp])+1 > (size_t)ARGV_MAX_SIZE)
	4528	? (size_t)ARGV_MAX_SIZE : strlen(argv[argp])+1,
	4529	"%s", argv[argp]);
	4530	my_argv[(int)strlen(my_argv)] = '\0';
	4531	for (i=(int)strlen(my_argv); i>=0; i--)
	4532	if (my_argv[i] <= 0x20)
	4533	my_argv[i] = '\0';
	4534	else break;
	4535
	4536	if (my_argv[0] == '-')
	4537	{
	4538	switch ((int)strlen(my_argv))
	4539	{
	4540	case 2 :
	4541	switch(my_argv[1])
	4542	{
	4543	case 'h' : PrintHelp() ; break ;
	4544	case 'c' : create.status = TRUE ; break ;
	4545	case 'q' : scan.limit = COLON_40 ; break ;
	4546	case 'e' : scan.err_order = ERROR_ORDER ; break ;
	4547	case 'd' :
	4548	case 'a' :
	4549	case 'b' :
	4550	case 's' :
	4551	case 'o' :
	4552	PrintAdvice (my_argv, "Option incomplete") ;
	4553	break ;
	4554	default :
	4555	PrintAdvice (my_argv, "Option inconnue") ;
	4556	break ;
	4557	}
	4558	break ;
	4559	case 3 :
	4560	switch(my_argv[1])
	4561	{
	4562	case 'b' :
	4563	switch(my_argv[2])
	4564	{
	4565	case 'l' : bin.type = LINEAR_FILE ; break ;
	4566	case 'd' : bin.type = DATA_FILE ; break ;
	4567	case 'h' : bin.type = HYBRID_FILE ; break ;
	4568	case 's' : break ;
	4569	default :
	4570	PrintAdvice(my_argv, "Parametre d'option inconnu") ;
	4571	break ;
	4572	}
	4573	break ;
	4574	case 's' :
	4575	switch(my_argv[2])
	4576	{
	4577	case 'e' : scan.symb_order = ERROR_ORDER ; break ;
	4578	case 't' : scan.symb_order = TYPE_ORDER ; break ;
	4579	case 'n' : scan.symb_order = TIME_ORDER ; break ;
	4580	default :
	4581	PrintAdvice(my_argv,"Parametre d'option inconnu") ;
	4582	break ;
	4583	}
	4584	break ;
	4585	case 'a' :
	4586	switch(my_argv[2])
	4587	{
	4588	case 'a' : scan.soft = SOFT_ASSEMBLER ; break ;
	4589	case 'm' : scan.soft = SOFT_MACROASSEMBLER ; break ;
	4590	default :
	4591	PrintAdvice (my_argv, "Parametre d'option inconnu") ;
	4592	break ;
	4593	}
	4594	break ;
	4595
	4596	default :
	4597	PrintAdvice (my_argv, "Option inconnue") ;
	4598	break ;
	4599	}
	4600	break ;
	4601	default :
	4602	switch(my_argv[1])
	4603	{
	4604	case 'o' :
	4605	line = &my_argv[2] ;
	4606	Ass_OPT() ;
	4607	memcpy(&scan.opt, &run.opt, sizeof(run.opt)) ;
	4608	break ;
	4609	case 'm' :
	4610	upper_string(&my_argv[2]) ;
	4611	i = 0 ;
	4612	while((i<3) && (!strcmp(&my_argv[2],Computer[i].name))) i++ ;
	4613	if (i == 3)
	4614	PrintAdvice (my_argv, "Parametre d'option inconnu") ;
	4615	else scan.computer = Computer[i].type ;
	4616	break ;
	4617	case 'd' :
	4618	i = ERR_ERROR ;
	4619	line = &my_argv[2] ;
	4620	if (ScanLine() == ALPHA_CHAR)
	4621	{
	4622	label[0] = '\0' ;
	4623	strcat(label,arg) ;
	4624	if ((ScanLine() == SIGN_CHAR)
	4625	&& (arg[0] == '='))
	4626	{
	4627	if (Eval() == NO_ERROR)
	4628	{
	4629	run.pass = PASS1 ;
	4630	i = DoSymbol(label,eval.operand,ARG_VALUE) ;
	4631	run.pass = SCANPASS ;
	4632	}
	4633	}
	4634	}
	4635	if (i != NO_ERROR) PrintAdvice (my_argv, "Erreur de parametrage") ;
	4636	break ;
	4637	default :
	4638	PrintAdvice (my_argv, "Option inconnue") ;
	4639	break ;
	4640	}
	4641	break ;
	4642	}
	4643	}
	4644	else
	4645	{
	4646	switch(fcount)
	4647	{
	4648	case 0 : snprintf (fload, ARGV_MAX_SIZE, "%s", my_argv); break ;
	4649	case 1 : snprintf (fsave, ARGV_MAX_SIZE, "%s", my_argv); break ;
	4650	default :
	4651	PrintAdvice (my_argv, "Argument excedentaire") ;
	4652	break ;
	4653	}
	4654	fcount++ ;
	4655	}
	4656	}
	4657
	4658	/*
	4659	* Vérification des arguments de lancement
	4660	*/
	4661	if (fload == NULL) PrintAdvice(fload,"Fichier source manquant") ;
	4662	if (fsave == NULL) PrintAdvice(fsave,"Fichier destination manquant") ;
	4663	if(!strchr(fload,'.')) PrintAdvice(fload,"Suffixe de fichier necessaire") ;
	4664	if(!strchr(fsave,'.')) PrintAdvice(fsave,"Suffixe de fichier necessaire") ;
	4665
	4666	/*
	4667	* Assemblage du source
	4668	*/
	4669	if (LoadFile(fload) == NO_ERROR)
	4670	{
	4671	if (OpenBin(fsave) == NO_ERROR)
	4672	{
	4673	/* Engagement pour le listing */
	4674	PrintListHeader(fload,fsave) ;
	4675
	4676	/* Assemblage du source */
	4677	AssembleSource(MACROPASS) ;
	4678	AssembleSource(PASS1) ;
	4679	AssembleSource(PASS2) ;
	4680
	4681	/* Enregistrement des erreurs */
	4682	PrintErrorList() ;
	4683
	4684	/* Enregistrement des symboles */
	4685	PrintSymbolList() ;
	4686
	4687	CloseBin() ;
	4688	}
	4689
	4690	if (filebuffer != NULL) free(filebuffer) ;
	4691	}
	4692
	4693	return CloseAll() ;
	4694	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: vital-to8-sdk/c6809/c6809.c @ 2

Download in other formats: