summary refs log tree commit diff stats
path: root/compiler/llstream.nim
Commit message (Collapse)AuthorAgeFilesLines
* case consistency: next stepsAraq2013-12-291-2/+2
|
* case consistency part 4Araq2013-12-271-13/+13
|
* case consistency part 1Araq2013-12-271-38/+37
|
* Removes executable bit for text files.Grzegorz Adam Hankiewicz2013-03-161-0/+0
|
* FFI at compiletime improvementsAraq2013-01-081-5/+12
|
* year 2012 for most copyright headersAraq2012-01-021-1/+1
|
* compiler uses new 'readLine'Araq2011-11-271-41/+30
|
* deprecated system.copy: use system.substr insteadAraq2011-05-141-1/+1
|
* big repo cleanupAraq2011-04-121-0/+229
h=main&id=64cf0a5950929e678ef9c0a6837ed59a1ca1661d'>^
5a481085 ^

215365d4 ^




5a481085 ^

215365d4 ^


37e4573b ^

dd2e01e4 ^
f1e09b14 ^
b24eb476 ^
dd2e01e4 ^
363be37f ^
37e4573b ^


91abd257 ^
363be37f ^
37e4573b ^


322ce34d ^
3ba63579 ^
5a481085 ^
3ba63579 ^


dd2e01e4 ^
363be37f ^
3ba63579 ^

b24eb476 ^
05d17773 ^
b24eb476 ^
05d17773 ^
3ba63579 ^
b24eb476 ^
05d17773 ^
3ba63579 ^





9cc16d04 ^
7f73795c ^
0f125d5f ^

37e4573b ^
a70ce311 ^





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
                                                                              


                                                                     









                                                                            
 
                             
                      

                                  

                     
                                             



                               

                     




                                                      

                   


                 

                      
                                                             
                                    
                                             
                                          
                                                                                            


                                               
                             
                                                     


                              
                                        
                                                                       
                      


                           
                                                                                            
                                                                                          

                                  
                                                         
                                            
                                                        
                                               
       
                                                     
                                            





                                 
                            
                                   

                                  
 





                                               
//: Phase 2: Filter loaded recipes through an extensible list of 'transforms'.
//:
//: The hope is that this framework of transform tools will provide a
//: deconstructed alternative to conventional compilers.
//:
//: We're going to have many transforms in mu, and getting their order right
//: (not the same as ordering of layers) is a well-known problem. Some tips:
//:   a) Design each layer to rely on as few previous layers as possible.
//:
//:   b) When positioning transforms, try to find the tightest constraint in
//:   each transform relative to previous layers.
//:
//:   c) Even so you'll periodically need to try adjusting each transform
//:   relative to those in previous layers to find a better arrangement.

:(before "End recipe Fields")
int transformed_until;
:(before "End recipe Constructor")
transformed_until = -1;

:(before "End Types")
typedef void (*transform_fn)(recipe_ordinal);

:(before "End Globals")
vector<transform_fn> Transform;

:(after "int main")
  // Begin Transforms
    // Begin Instruction Inserting/Deleting Transforms
    // End Instruction Inserting/Deleting Transforms

    // Begin Instruction Modifying Transforms
    // End Instruction Modifying Transforms
  // End Transforms

  // Begin Checks
  // End Checks

:(code)
void transform_all() {
  trace(9990, "transform") << "=== transform_all()" << end();
//?   cerr << "=== transform_all\n";
  for (int t = 0; t < SIZE(Transform); ++t) {
//?     cerr << "transform " << t << '\n';
    for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
      recipe& r = p->second;
      if (r.steps.empty()) continue;
      if (r.transformed_until != t-1) continue;
      // End Transform Checks
      (*Transform.at(t))(/*recipe_ordinal*/p->first);
      r.transformed_until = t;
    }
  }
//?   cerr << "wrapping up transform\n";
  parse_int_reagents();  // do this after all other transforms have run
  // End Transform All
}

void parse_int_reagents() {
  trace(9991, "transform") << "--- parsing any uninitialized reagents as integers" << end();
  for (map<recipe_ordinal, recipe>::iterator p = Recipe.begin(); p != Recipe.end(); ++p) {
    recipe& r = p->second;
    if (r.steps.empty()) continue;
    for (int index = 0; index < SIZE(r.steps); ++index) {
      instruction& inst = r.steps.at(index);
      for (int i = 0; i < SIZE(inst.ingredients); ++i) {
        populate_value(inst.ingredients.at(i));
      }
      for (int i = 0; i < SIZE(inst.products); ++i) {
        populate_value(inst.products.at(i));
      }
    }
  }
}

void populate_value(reagent& r) {
  if (r.initialized) return;
  // End Reagent-parsing Exceptions
  if (!is_integer(r.name)) return;
  r.set_value(to_integer(r.name));
}

// helper for tests -- temporarily suppress run
void transform(string form) {
  load(form);
  transform_all();
}