1. Caractères -- chaînes de caractères
2. Exceptions
3. Entrées-Sortie
4. Filtrage naif
5. Filtrage linéaire
6. Rappel sur les automates finis
7. Expressions régulières
8. Analyse lexicale

char c = 'a';

String s = "Vive l'informatique!"

String x = "a" + 4 + "c"

String x = new StringBuffer().append("a").append(4).append("c").toString()

static int parseInt (String s) {
  int r = 0;
  for (int i = 0; i < s.length(); ++i)
    r = 10 * r + s.charAt(i) - '0';
  return r;
}

• Retourner une valeur réservée: -1 par exemple. Laid!
  
  
• Lever une exception.

static int parseInt (String s) {
  int r = 0;
  for (int i = 0; i < s.length(); ++i) {
    if (!Character.isDigit (s.charAt(i)))
      throw new Error ("Pas un nombre");
    r = 10 * r + s.charAt(i) - '0';
  }
  return r;
}

static int parseInt(String s) throws NumberFormatException {
  int r = 0;
  for (int i = 0; i < s.length(); ++i) {
    if (!Character.isDigit (s.charAt(i)))
      throw new NumberFormatException (s);
    r = 10 * r + s.charAt(i) - '0';
  }
  return r;
}

    java.lang.Object
       +----java.lang.Throwable
               +----java.lang.Error
               +----java.lang.Exception
                       +----java.lang.RuntimeException
                               +----java.lang.IllegalArgumentException
                                       +----java.lang.NumberFormatException

public static void main (String[] args) {
  try {
    int x = parseInt (args[0]);
    System.out.println (x);
  } catch (NumberFormatException e) {
    System.err.println ("Mauvais argument: " + e.getMessage());
  } catch (ArrayIndexOutOfBoundsException e) {
    System.err.println ("Mauvais nombre d'arguments");
  }
}

import java.io.*;

class IO {
  public static void main (String[] args) {
    BufferedReader in = 
        new BufferedReader(new InputStreamReader(System.in));
    try {
      String s;
      while ((s = in.readLine()) != null) {
        int n = Integer.parseInt(s);
        System.out.println(n);
      }
    } catch (IOException e) {
      System.err.println(e);
    }
  }

static int match (String s, String t) {
  int m = s.length(), n = t.length();
 loop:
  for (int i = 0; i + m <= n; ++i) {
    for (int j = 0; j < m; ++j) 
      if (t.charAt(i+j) != s.charAt(j))
        continue loop;
    return i;
  }
  return -1;
}

static int[] preprocess(char[] s, int m) {

  int[] next = new int[m+1];

  int j = 0; int t = -1; next[0] = -1;
  while (j < m) {
    while (t >= 0 && s[j] != s[t]) 
      t = next[t];
    ++t; ++j;
    next[j] = t;
  }
  return next;
}

• Mécanisme d'un distributeur automatique
• Protocoles réseau (bit alterné, etc)
• Peloton d'exécution (Firing squad problem)
• Systèmes réactifs
• Contrôle dans les circuits
• Analyseurs lexicaux

• En dur dans le contrôle (fini) du programme
  
  

  
  int c = in.read(); int q = q0;
  switch (q) {
    case 0: if (c == 'a') ... else if (c == 'b)  ...; break;
    case 1: if (c == 'b') ... else if (c == 'c) ... ; break;
    ...
    case 10: if ...  break;
  }
  

• vecteur de |Q| listes d'association (c', q')
  
  
• matrice |Q| × |S| de transition (éventuellement compressée).

• L = { xaay | x,y Î S^* } È { xbby | x,y Î S^* }
  
  
• L = L₁ È L₂ où L₁ et L₂ sont reconnus par des automates finis
  
  
• L = { xwy | x,y Î S^* } où w est un mot donné.

% man awk
% man lex
% man sed

class PremierProg {
    public static void main (String[ ] args){
        System.out.println ("Bonjour les forts!");
        System.out.println ("fib(20) = " + fib(20));
    }
}

IDENT(class) IDENT(PremierProg) ACCG IDENT(public) IDENT(static)
IDENT(void) IDENT(main) PARG IDENT(String) CROG CROD IDENT(args) 
ACCG IDENT(System) POINT IDENT(out) POINT IDENT(println) PARG
CHAINE(Bonjour les forts!) IDENT(System) POINT IDENT(out) POINT
IDENT(println) PARG CHAINE(fib(20) = ) PLUS IDENT(fib) PARG NOMBRE(20)
PARD PARD POINTVIRGULE ACCD ACCD FINFICHIER

class Lexeme {

  final static int NOMBRE=0, IDENT=1, OP=2;
  int nature;
  String as_var; int as_int; char as_op;

  Lexeme (int i) { nature = NOMBRE; as_int = i; }

  Lexeme (String s) { nature = IDENT; as_var = s; }

  Lexeme (char op) { nature = OP; as_op = op; }

This document was translated from L^AT_EX by H^EV^EA.