Utilisation du compilateur MTASC

Par défaut MTASC s'utilise en ligne de commande, pour un usage basic seul cinq paramètres sont nécessaire.

Les paramètres de base

  • -swf fichier.swf
    Cible sur le fichier swf que l'on veut en entrée, ce qui permet d'imputer du code dans un swf existant.

  • -cp chemin
    Ajoute le chemin d'un dossier comme «ClassPath» (Flash < préférences < ActionScript < Paramètres d'ActionScript < Chemin de Classes). Vous pouvez utiliser une série de -cp pour ajouter un série de dossiers.

  • -main
    Force l'appel de la fonction statique «main» dans toutes les classes enregistrée.

  • -header width:height:fps:bgcolor
    Si aucun swf n'est chargé en entrée (-swf fichier.swf), ces paramètres seront utilisé pour créer un nouveau swf. Le «bgcolor» est facultatif, c'est une valeur hexadécimal.

  • -mx
    Permet d'utiliser les classes précompilé de Flash (en cas d'utilisation des composants V2 de MM).

Les paramètres avancées

  • -version nombre
    Défini la version du swf généré : 6 pour générer un swf compatible avec le Flash Player 6r89 ou 8 pour accéder au nouveautés de Flash 8.

  • -v
    Active le mode «verbose» (bavard) ce qui permet d'avoir des informations complémentaire dur le processus de compilation.

  • -out fichier.swf
    change le nom du fichier obtenu en sortie.

  • -msvc
    Emploie le formatage d'erreurs de Microsoft Visual Studio au lieu du modèle de Java (pour le le nom des fichiers et le nombre de lignes).

  • -strict
    Emploie le mode strict pour la compilation ce qui oblige d'avoir toutes les variables explicitement typé.

  • -exclude chemin
    Exclu la génération de code des classes contenu dans les dossiers imbriqué (un chemin par ligne).

  • -trace fonction
    Spécifie une fonction personnel pour la fonction trace, si le paramètre est vide toutes les fonctions trace sont neutralisé.

  • -keep
    Maintient les classes déjà présentent dans le swf utilisé en entré (il peut donc arriver d'avoir deux fois la même classe dans un swf).

  • -frame image-clef
    Défini l'image-clef où seront chargé les classes ActionScript.

  • -pack chemin
    Permet de définir un chemin de sortie, équivalent au chemin de sortie défini des paramètres de publication de l'IDE de Flash - non récurcif (exemple sous osX pour compiler dans le dossier /User/ali_o_kan/document/monProjet/sortie faite -cp /User/ali_o_kan/document/monProjet -pack monProjet/sortie).

  • -group
    Fusionne les classes dans un seul clip (permet de réduire le poids du swf mais peut poser problème si les paramètres -keep ou -mx sont utilisé).

  • -wimp
    Ajoute des messages d'erreur pour les import non utilisé dans les swf.

  • -infer
    Type automatiquement les variables locales, ce qui permet d'éviter des redondances(ex. var monOccurence:MaClasse = new MaClasse (); ).

Explication d'utilisation

Pour pouvoir compiler avec MTASC il faut, MTASC et une classe d'entrée. Pour installer MTASC suivez les liens( Linux, osX, Win ). Pour ce qui est de la classe d'entrée il s'agit d'une classe qui pocède une fonction statique «main». C'est par cette fonction que l'application sera lancé. Chose interressante à savoir, la fonction «main» pocède un argument, il s'agit du level0 du swf (le _root). Maintenant il ne vous reste plus qu'a publier avec MTASC et vous obtiendrez un joli swf en sortie, «elle est pas belle la vie?» :)

Exemple basic

Dans cette exemple aucun swf ne serra utilisé en entrée, uniquement une classe ActionScript2.

La classe d'exemple

class Exemple
{
static var app : Exemple;
 
function Exemple( mc:MovieClip )
{
// créé un TextField 'tf' de 800x600 en position 0,0
mc.createTextField("tf",0,0,0,800,600);
// ecrit le text «Hello world !» dedans
mc.tf.text = "Hello world !";
}
 
// Point d'entrée
static function main( mcRoot:MovieClip ) : Void
{
app = new Exemple( mcRoot );
}
}

La ligne de commande

/opt/mtasc/mtasc  -swf exemple.swf -main -header 800:600:30 Exemple.as

/opt/mtasc/mtasc -> cible le compilateur MTASC
-swf exemple.swf -> cible le swf utilisé en entré, comme inexistant dans l'exemple exemple.swf sera le nom du fichier en sortie.
-main -> Lance la fonction statique main de Exemple.as
-header 800:600:30 -> paramètres du fichier swf créé, 800px x 600px, 30fps.
Exemple.as -> utilise Exemple.as comme fichier d'initialisation, qui contient la fonction statique main.
Dans cette exemple aucun ciblage vers un chemin de classe (-cp) n'a du être fait, car l'objet TextField utilisé est un objet intrinsèque de Flash, càd que sont code est contenu dans le Flash playeur.

Exemple d'utilisation d'un composant d'Adobe.

Avant de continuer, je vous conseil d'aller jetter un oeil au projet ActionStep. ;)

Pour utiliser les composant V2 d'Adobe avec MTASC, il faut utiliser le parametre -mx.

  • Pour commencer on écrit la classe Test qui utilise le composant Alert.
  • class Test {
function Test()
{
mx.controls.Alert.show("Salut les gens!","titre");
}
}
  • Ensuite dans l'IDE de Flash créer un nouveau fla (test.fla).
  • Placer sur la première image-clef le code suivant : 
    var t:Test = new Test();
  • Placer le composant Alert dans la bibliothèque.
  • Publier, le composant devrait apparaître dans le swf (test.swf). :)
  • A partir de maintenant on peut fermer Flash, le swf contient tout ce dont on a besoin.
  • Il reste plus qu'a modifier la classe Test.as à notre guise et de publier avec MTASC. :)
  • mtasc -main -mx -swf test.swf -out sortie.swf
-cp "(le chemin de classe de Macromedia)" -cp Test.as

Petite remarque concernant le chemin de classe sous MacOsX, par défaut le chemin contient des espace dans le nom du dossier Flash : "/Applications/Macromedia Flash 8/First Run/Classes", ce qui entraîne l'erreur suivante : "(unknown) : type error class not found : Flash". erixtekila à donné une solution sur la ML d'osFlash cette semaine, il suffit de créer un lien symbolique UNIX («Alias») qui ne contient pas d'espace et qui renvoi directement sur le dossier mx. Enfin c'est la méthode élégante, il en existe une autre, qui conciste à copier le dossier mx pour ne plus avoir le «Macromedia Flash 8/First Run», à vous de voir ;)

Exemple d'utilisation du parametre -trace.

Avec MTASC on peut utiliser des fonction trace personnalisée. :)

class Test {
function Test() {
TRACE("coucou, c'est moi!");
}
}

Après compilation avec MTASC

mtasc -trace MaClasse.monTracePerso

MTASC remplace les trace() par la fonction MaClasse.monTracePerso.
MaClasse.monTracePerso("coucou, c'est moi!", "Test::test", "Test.as", 3 );

Comme on peut le voir MTASC ajoute 3 arguments :

  • le nom de la classe suivit de la fonction
  • Le nom du fichier
  • le numéro de la ligne

Transformer les trace en Logger.LOG de pixLib

La plus part de mes ancien projet j'utilisais la fonction trace() pour déboguer, mais depuis quelques semaines j'utilise les logguer de pixLib, je viens donc monté une petite classe pour transformer les trace() en Logger.LOG

/**
* @author [ali_o_kan] - Laurent Deketelaere
*/
import com.bourre.log.LogLevel;
import com.bourre.log.LogChannel;
 
class LOG2MTASC extends com.bourre.log.Logger
{
public static var traceChannel : LogChannel = new LogChannel("TRACE");
/*
* @param o contenu du trace()
* @param sFunction nom de la classe et de la methode d'où est appelé le trace()
* @param sFile nom du fichier
* @param nLine numéro de la ligne
*/
public static function LOG( o, sFunction:String, sFile:String, nLine:Number ) : Void
{
var oTrace = {_trace:o, _fonction:sFunction, _fichier:sFile, _ligne:nLine};
getInstance().log( oTrace, LogLevel.DEBUG, traceChannel );
}
}
Utilisation
/**
* @author [ali_o_kan] - Laurent Deketelaere
*/
import com.bourre.utils.LuminicTracer;
import com.bourre.log.Logger;
 
class Main {
static var app : Main;
function Main()
{
Logger.getInstance().addLogListener( LuminicTracer.getInstance(), LOG2MTASC.traceChannel );
boucle();
}
public static function main() : Void
{
app = new Main();
}
function boucle() : Void
{
for(var i:Number = 0; i<15; i++)
{
trace("une boucle"+i);
}
}
}
MTASC
/opt/mtasc/mtasc -header 800:600:25  -main  -swf test_trace.swf
-trace LOG2MTASC.LOG
-cp /Users/ali_o_kan/Documents/eclipse/tester/pixLib
-cp /Users/ali_o_kan/Documents/eclipse/pixLib/src  Main
Sortie

Je retrouve dans le FlashInspector mes trace qui renvoit un objet contenant :

{
_trace: une boucle0,
_function: Main::boucle,
_fichier: Users/ali_o_kan/Documents/eclipse/tester/src/Main.as
_ligne: 27
}

-trace no

Pour finir avec l'argument -trace, lorsque le débogue est fini, il suffit de faire:

/opt/mtasc/mtasc -header 800:600:25  -main  -swf test_trace.swf  -trace no
-cp /Users/ali_o_kan/Documents/eclipse/tester/pixLib
-cp /Users/ali_o_kan/Documents/eclipse/pixLib/src Main

Comparaison avec le compilateur de Macromedia (Adobe).

  • Plus rapide,
    il faut 3 à 4 secondes à MTASC pour compiler 300 classes, ce qui met entre 20 à 30 secondes avec le compilateur de MM.

  • Moins cher,
    MTASC est gratuit et open-source, ce qui fait qu'on est certains que son amélioration ne serra jamais stoppé.

  • Gestion du scoppage des variables local,

    function f()
{
var x = 1;
if( true )
{
var x = "hello";
// ...
}
trace(x+1);
}

    Sortie MM : hello1, Sortie MTASC : type error Local variable redefinition : x, MTASC interdit la redéfinition de variable local pour éviter tous problèmes au niveau du typage.

    function f() {
{
var x : Number = 1;
// ... ici x est un nombre
}
// ici aucun accès à x
{
var x : String = "hello";
// ... ici x est une chaine
}
// ici aucun accès à x
}

  • #include,
    n'est plus géré car devenu obsolète avec l'ActionScript 2.

  • Fonctions local,
    alors que le compilateur Macromedia accèpte les fonctions nommé,

    function f(x)
{
function g(y)
{
return x+y;
}
}

    MTASC autorise que la définition de fonctions local anonyme.

    function f(x)
{
var g:Function = function(y)
{
trace(x+y);
}
}

  • Typage strict des Tableaux,
    permet de typé les données contenu dans un Array.

    var tmp = new Array();
var a : /*Number*/ Array = tmp;

  • Typage local des variable inférence (-infer),

    var x : String = "hello";
var x : Number = Math.cos(Math.PI);
var x : MyClass = new MyClass();
    var x = "hello";
var x = Math.cos(Math.PI);
var x = new MyClass();
  • Changements mineurs,
    • arguments est supporté, mais pas via des appel dynamique (par exemple eval('arguments"); ).
    • Le retour variables getter doit être le même que celui des setter et doit être spécifié.
    • Les fonctions sans retour sont automatiquement typé en Void.
    • eval("this") n'est pas effectué.

Je terminerai en disant merci à Nicolas, qui nous offre un compilateur digne du nom.

infos +